Customer profile
The team in this case study works in the mechanical engineering discipline at a mid-size building services consultancy. Their day-to-day output consists of construction documentation for commercial and institutional HVAC systems — supply air ductwork, exhaust paths, diffuser layouts, and the fabrication-and-installation detail sheets that contractors and inspectors rely on during a build.
Technical staff span two overlapping roles. HVAC engineers own the system design and sign off on specifications; CAD technicians translate those designs into drawing packages. Both roles regularly deal with complex multi-section DWG files that arrive from subconsultants or are produced in-house and must then be packaged into client-ready deliverables. Those deliverables typically include structured schedules in Excel, human-readable documentation for project coordination, and coverage-audit artifacts that prove no section of the drawing was overlooked.
Problem
The drawing in question was a full HVAC ducting details sheet containing more than twenty distinct construction and specification sections. Named sections in the file included duct insulation details, duct hanger details, supply ceiling diffuser configurations, flexible connection details, typical branch duct details, duct-through-wall details, plenum box details, diffuser details, seam specifications for round duct and fittings, minimum hanger sizes for round duct, round duct gauge selection tables for galvanized steel, duct joint and seam details, intermediate stiffening construction details, ductwork pressure duct joints, and additional labeled references — Detail A, Detail B, and acoustic duct liner details.
Working through a file this size manually imposed a compounding set of problems. First, DWG files are not directly interoperable with all downstream tools: converting to DXF requires either a full AutoCAD seat or a dedicated conversion utility, and the output needs to be validated. Second, the raw DXF geometry is not self-explanatory — section boundaries, annotation text, and table lines exist as separate entity types with no inherent parent-child relationship. Determining which text belongs to which section requires spatial reasoning over thousands of entity coordinates. Third, the low-velocity ductwork schedule — a 7-column, 9-row reference table embedded in the drawing — needed to be extracted into a formatted Excel file for use in quantity take-offs and contractor communications. Reconstructing a table from DXF text-position data and line geometry is time-consuming even for experienced technicians, and the risk of a transposition error or missed row is real.
Finally, before sharing deliverables with external parties, the team needed a coverage audit: explicit confirmation that every named section had been accounted for and documented, not just the sections that were easy to find.
Why now
The immediate trigger was a project milestone handoff. The team had committed to delivering a complete drawing-package summary and structured schedule to the general contractor by end of week. With multiple engineers working across different project phases simultaneously, there was no spare capacity to assign the extraction and documentation work to a single person for a full day. The task needed to be completed faster than the manual process allowed, without trading away accuracy.
A secondary pressure was format interoperability. The contractor's estimating software accepted DXF but not DWG, so the format conversion was not optional. Doing the conversion, then the section inventory, then the table extraction, then the documentation — as four sequential manual operations — would have consumed the better part of a working day even before any review cycles.
Why energent.ai
The team evaluated several approaches before using energent.ai. A scripted AutoCAD macro could handle the format conversion but would not produce section documentation or Excel extraction without significant custom development. A standalone DXF parsing library in Python was viable for a developer but not for the engineers and technicians who needed to turn the work around quickly without writing code. Hiring a drafter to do the manual transcription was considered, but the turnaround time was incompatible with the deadline.
energent.ai offered a different profile: a data-analysis agent that could accept binary CAD files directly, run Python and shell commands against them without requiring the user to write any code, produce multiple output formats from a single session, and explain its reasoning in plain language. The team could upload the DWG file, describe what they needed, and let the agent handle the format conversion, spatial parsing, table reconstruction, and documentation generation — reviewing outputs at each step rather than building and debugging scripts themselves.
The agent's ability to generate both machine-readable outputs (DXF, XLSX) and human-readable audit artifacts (HTML dashboards, markdown documentation) in a single session was the deciding factor.
Workflow
The workflow proceeded in six logical stages, all within a single energent.ai session.
Stage 1 — Format conversion. The team uploaded the DWG file. The agent converted it to an interoperable DXF file and produced a conversion summary dashboard as an HTML file. The dashboard reported the DXF version, layout names, entity counts, and output file size — giving the team an immediate sanity check that the conversion had captured the full drawing.
Stage 2 — Sheet-logic analysis. The agent parsed the DXF structure and generated a sheet-logic dashboard. This HTML artifact described the drawing at a high level: the drawing type (HVAC ducting details sheet), the main detail groups present, and how the DXF content logically fit together — context that would otherwise require an engineer to read through the raw file manually.
Stage 3 — Section inventory and documentation. The agent scanned the DXF for named section boundaries and produced a section-by-section markdown explanation covering all discovered sections. The markdown included plain-language descriptions of what each subsection is for and how it fits into HVAC duct design logic. The agent also produced a subsection inventory dashboard — an HTML visualization mapping each discovered main section and supporting subsection to its documentation entry, confirming that no material section had been missed.
Stage 4 — Coverage validation. Before proceeding to extraction, the agent cross-checked its markdown output against the DXF inventory. It confirmed explicit coverage for six primary sections (duct insulation detail, duct hanger detail, supply ceiling diffuser, flexible connection detail, typical branch duct detail, and duct-passing-through-wall detail) and all supporting and global subsections listed in the drawing.
Stage 5 — Low-velocity ductwork table extraction. The agent located the low-velocity ductwork schedule within the DXF by searching for the associated note text and scanning nearby text and line geometry. It reconstructed the table grid from DXF spatial data, isolating 7 columns and 9 table rows. It then wrote the table to an Excel workbook with the first row highlighted red across all header cells, and appended the defining low-velocity note below the table: the note specifies that low-velocity ductwork is ductwork in which velocity does not exceed 9.144 m/s and static pressure does not exceed 500 pascals.
Stage 6 — Deliverable consolidation. The agent listed all six generated files with a plain-language description of each file's purpose and how the files fit together as a package, giving the team a ready-made handoff inventory to accompany the submission.
Results
At the end of the session, the team had six production-ready deliverables:
- A converted DXF file for use with contractor estimating software.
- An HTML conversion dashboard confirming file structure and entity counts.
- An HTML sheet-logic dashboard providing a plain-language overview of the drawing.
- A markdown document explaining all 20-plus detail sections for project coordination.
- An HTML subsection coverage dashboard auditing section completeness across all named sections.
- An Excel workbook containing the reconstructed 7-column, 9-row low-velocity ductwork schedule with a formatted and highlighted header row and the defining engineering note appended.
The section documentation and coverage audit — which would typically require a technician to work through the file section by section over several hours — were produced automatically with full coverage confirmed against the DXF inventory. The table extraction, traditionally a manual transcription task prone to transposition errors, was completed programmatically from the drawing geometry and validated against the source DXF before delivery. The team met the contractor handoff deadline without pulling an engineer off another project phase.
Proof
"We needed the ductwork schedule in Excel and a clean section summary to hand off before Friday. Normally that's half a day of manual work — opening the file, finding the table, typing it out, checking you got every section. The agent found all twenty-something sections, pulled the table from the DXF geometry, and flagged the low-velocity note underneath it. The Excel came out formatted and ready to use. I did a spot-check against the drawing and it matched." — HVAC CAD technician
The subsection coverage dashboard the agent produced — a visual grid mapping each discovered section to its documentation entry — was included in the client submission package as a completeness certificate. The Excel extraction with its red-highlighted header row was passed directly to the contractor's estimating team.
Trust note
The low-velocity ductwork schedule was reconstructed algorithmically from DXF text positions and table-line entities rather than read from a native spreadsheet. Minor wording or spelling variations from the original CAD annotation are possible, and column alignment should be verified against the source drawing before the Excel file is used in a binding quantity take-off or submitted as a contract document. Similarly, the section documentation reflects the agent's spatial parsing of the DXF and should be reviewed by the project engineer before being shared as a formal design narrative. The HTML dashboards are audit aids for internal coverage checking, not engineering certificates or regulatory submissions.