steel-tools
Server Details
Steel takeoff, weight and gauge calculators plus RFQ, RFI, NCR and Bluebeam markup generators.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Tool Definition Quality
Average 4.3/5 across 14 of 14 tools scored.
Each tool has a clearly distinct purpose: lookups (bolt pretension, gauge, pipe, shape), weight calcs (plate, section, shape, takeoff), area calc, reference, MTR screening, and PDF/document generators (NCR, RFI, RFQ, markup). Even the three weight tools are explicitly differentiated by input type, and the descriptions cross-reference each other to avoid confusion.
All tool names share the 'steel_' prefix and follow a 'resource_property/action' pattern (e.g., steel_plate_weight, steel_rfi_generate). However, the suffix is not uniformly a verb or noun: some end with a noun (steel_coating_area, steel_pipe_schedule) and others with a verb (steel_mtr_check, steel_ncr_generate), creating minor inconsistency in the naming convention.
14 tools is well within the ideal 3-15 range for a specialized domain. Each tool covers a distinct need for structural steel estimating and documentation, and the count feels comprehensive without being bloated or redundant.
The tool set provides thorough coverage of the structural steel domain: reference lookups, weight/size calculations, coating area, MTR checking, takeoff rollups, and formal document generation (NCR, RFI, RFQ) plus PDF markup. There are no obvious missing operations for a steel estimating/quality document workflow, and the tools together enable a complete estimating and documentation process.
Available Tools
14 toolssteel_bolt_pretensionBolt Pretension & Turn-of-the-NutAInspect
RCSC minimum pretension for A325/A490 structural bolts by diameter, with the turn-of-the-nut rotation when a bolt length is given. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| dia | Yes | Bolt diameter in inches — fraction ("3/4") or decimal (0.75) | |
| length_in | No | Optional bolt length in inches, for the turn-of-the-nut rotation |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It discloses that values are 'nominal' and 'not design guidance,' which is an important caveat about the tool's reliability and intended use. It also indicates that rotation is provided only 'when a bolt length is given,' setting expectations for conditional behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the core purpose and followed by a vital caveat. Every phrase earns its place: it identifies the standard (RCSC), the bolt grades (A325/A490), the input (diameter, optional length), and the output type (pretension, rotation), with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has only 2 parameters, no output schema, and no annotations, but the description provides sufficient context for a simple lookup: it names the inputs, the output concept (minimum pretension, turn-of-the-nut rotation), and the important caveat about design use. It does not explicitly state the units of the returned pretension or whether both values are always returned, but the description is adequate for the tool's modest complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with dia and length_in already fully documented in the input schema (e.g., 'fraction ("3/4") or decimal (0.75)' and 'for the turn-of-the-nut rotation'). The tool description merely restates this information ('by diameter,' 'when a bolt length is given') without adding new meaning, so a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides 'RCSC minimum pretension for A325/A490 structural bolts by diameter' and 'turn-of-the-nut rotation' when length is given. This distinctly identifies the resource (bolt pretension values) and separates it from the sibling tools (e.g., steel_plate_weight, steel_shape_weight), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly notes 'Published nominal values for estimating and orientation, not design guidance,' providing clear when-to-use (estimating/orientation) and when-not-to-use (design) guidance. It does not name alternative tools, but the exclusion is explicit and the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_coating_areaCoating / Surface AreaAInspect
Surface area to coat for an AISC shape: ft² per foot from the cross-section perimeter, piece/lot area with length and qty, optional interior faces for galvanized tubes and gallons at a supplied coverage rate. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| qty | No | Optional piece count (default 1) when a length is given | |
| length_ft | No | Optional length in feet for a piece/lot area | |
| designation | Yes | AISC designation, e.g. W21X50, HSS6X6X3/8, Pipe4STD | |
| include_inside_faces | No | Tubes only: add interior surface, as hot-dip galvanizing coats vented HSS/pipe interiors. Default false (outside only). | |
| coverage_sqft_per_gal | No | Optional practical coverage rate from the coating datasheet, to estimate gallons |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and discloses calculation basis (cross-section perimeter), optional interior faces for galvanized tubes, and coverage-rate-based gallons. It also sets expectations as nominal estimates.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences convey the full purpose, key parameters, calculation modes, and an important caveat without redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers what is calculated, parameter relationships, and the estimating limitation. It lacks explicit return structure, but no output schema exists and the primary outputs are clearly implied.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema already documents all 5 parameters (100% coverage), but the description adds meaningful context: how length/qty combine for piece/lot area, when interior faces apply, and how coverage rate yields gallons.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool computes 'Surface area to coat for an AISC shape' and enumerates specific outputs (ft² per foot, piece/lot area, gallons), distinguishing it from sibling weight/bolt/etc. tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clarifies it is for 'estimating and orientation, not design guidance,' giving a clear usage boundary. It does not explicitly name alternative tools, but the purpose is well-scoped enough to guide selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_connection_referenceSteel Connection ReferenceAInspect
Describe a structural steel connection type (behaviour, use, what goes wrong) by name, alias or slug — or look up a structural bolt grade (A325, A490, A307). Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| name_or_slug | Yes | Connection name, alias or slug (e.g. "clip angle", "base-plate") or a bolt grade (e.g. "A490") |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description is responsible for behavioral disclosure. It reveals that returned values are nominal and not authoritative, which is a critical caveat for a reference tool. It also implies a read-only, lookup behavior consistent with the verbs 'describe' and 'look up'. However, it doesn't specify response format or error behaviors for unrecognized names.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action ('Describe... or look up'), and includes the essential caveat in the second sentence. No word is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter lookup tool, the description provides adequate context: what it does, what it returns (nominal values), and its limitation. Without an output schema, the description partially covers return expectations, though it could mention the exact format (e.g., text vs. structured data) more explicitly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description already fully covers the only parameter, name_or_slug, with examples for both connection types and bolt grades. The main description reiterates this dual-purpose but adds no new semantic information beyond what the schema provides, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly defines the tool's function: describing steel connection types (behaviour, use, failure modes) and looking up bolt grades. The verbs 'describe' and 'look up' are specific, the resource is distinct, and it differentiates from sibling tools (gauge, plate weight, shape weight) by resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states the intended use ('for estimating and orientation') and the exclusion ('not design guidance'), which is a strong usage boundary. It doesn't name sibling tools, but the resource differences make the appropriate context clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_gauge_thicknessSteel Gauge ThicknessAInspect
Look up sheet steel gauge thickness (gauges 3-28) in inches and mm with lb/ft², for plain, galvanized or stainless series. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| gauge | Yes | Sheet steel gauge number, 3 through 28 | |
| material | No | Gauge series — the same number is a different thickness each | steel |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the values are 'published nominal values' and specifies contexts where they should not be used (design guidance). It also states the units returned, providing useful behavioral context beyond a simple lookup. It does not detail error behavior for out-of-range gauges, but the schema min/max provides that.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence. It front-loads the primary action and resource, states the parameter scope, and includes a necessary caveat in a compact final clause. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple lookup tool with two parameters and no output schema, the description provides all essential context: the range of gauges, material variants, output units, and the intended usage (estimating) with a caveat. This is sufficiently complete for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the description need not compensate. The description mentions the gauge range (3-28) and material series, but these are already captured in the parameter descriptions. It adds no new semantic information beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool looks up sheet steel gauge thickness in inches, mm, and lb/ft², for three material series. The verb 'look up' and the resource 'sheet steel gauge thickness' are specific and distinguish it from sibling tools like weight calculators.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly indicates when to use this tool: for estimating and orientation. It also provides a clear exclusion: 'not design guidance.' However, it does not explicitly name alternative tools for when more precise or design-grade data is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_mtr_checkMill Test Report Mechanicals ScreenAInspect
Screen a mill cert's yield and tensile against the specified limits for A992, A572 Gr. 50 or A36 — a screening aid, not acceptance. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| grade | Yes | Steel grade: "A992", "A572 Gr. 50" or "A36" | |
| yield_ksi | Yes | Reported yield, ksi | |
| tensile_ksi | Yes | Reported tensile, ksi |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the tool is a screening aid using published nominal values, not acceptance or design guidance. However, it does not describe the output format or behavior (e.g., pass/fail result), leaving some ambiguity for a 3-parameter tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is two sentences, front-loaded with the primary action and purpose. Every clause adds value: 'screening aid, not acceptance' and 'nominal values for estimating... not design guidance' are concise and avoid redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 3-parameter tool with no output schema or annotations, the description explains the purpose and limitations but omits details about what the tool returns or how results are presented. This leaves the agent to infer output behavior, making it adequate but with a clear gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all three parameters (grade, yield_ksi, tensile_ksi) with descriptions. The description adds context by linking yield and tensile to the screening limits and naming specific grades, but does not go beyond the schema's core meaning, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool screens mill cert yield and tensile against specified limits for A992, A572 Gr. 50, or A36. The verb 'screen' is specific and the resource is well-defined, distinguishing it from steel-related sibling tools that handle bolt pretension, connections, gauge thickness, plate weight, and shape weight.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description provides explicit context on when to use (for screening/estimating) and when not to use (not for acceptance, not design guidance). However, it does not explicitly name alternative tools for comparison, though the siblings imply other use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_ncr_generateNCR Document GeneratorAInspect
Generate a formal Nonconformance Report PDF: identification, description, the violated requirement, containment, root cause (prose or 5-Whys chain), disposition (accept-as-is/repair/rework/reject) with actions, and blank quality-review and sign-off blocks. Flags accept-as-is dispositions whose corrective action describes physical work. The disposition decision belongs to the responsible quality authority. Returns a download link that expires within ~48 hours. Nothing you submit is stored.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | Date raised | |
| location | No | Area, level, grid, or piece mark | |
| raised_by | Yes | Name — role | |
| ncr_number | Yes | NCR number from the project register, e.g. "NCR-008" | |
| resolution | Yes | Disposition: accept-as-is (no physical work), repair, rework, or reject | |
| root_cause | No | ||
| containment | No | What was done on the spot — quarantine, stop work, tag | |
| description | Yes | What was found, measured against what was required | |
| company_name | Yes | Contractor raising the NCR — appears in the header | |
| project_name | Yes | ||
| project_number | No | ||
| root_cause_whys | No | 5-Whys chain, first why to root; overrides root_cause | |
| company_location | No | ||
| corrective_action | No | Bringing this instance into compliance | |
| preventive_action | No | Stopping recurrence — procedure, inspection, supplier | |
| trade_or_supplier | No | ||
| requirement_violated | Yes | The cited requirement — spec section, drawing/detail, or code clause. An NCR without a cited requirement is dispute fuel. | |
| resolution_justification | No | Required in practice for accept-as-is — the concession basis |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses key behaviors: flags inconsistencies between accept-as-is disposition and corrective_action containing physical work, returns a download link expiring in ~48 hours, and states that submitted data is not stored. These are meaningful operational traits beyond what the schema captures.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loads the core purpose, and every clause provides distinct value — content composition, a validation flag, authority note, output expiry, and privacy. No filler or redundant restatement of the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex 18-parameter tool with no output schema, the description covers the essential context: what the PDF contains, how output is delivered, expiry, and privacy. It also alerts users to a critical validation behavior. The schema handles most parameter details, and the description fills the remaining conceptual gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 72%, and the description adds conceptual grouping of parameters (root cause prose or 5-Whys chain, disposition with actions, blank review blocks). It also hints at a relationship between resolution and corrective_action by flagging contradictions. While it does not describe every parameter, it supplements the schema meaningfully.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Generate a formal Nonconformance Report PDF' — a specific verb and resource — and enumerates the report contents (identification, description, violated requirement, containment, root cause, disposition, actions). This clearly distinguishes it from sibling generators like steel_rfi_generate or steel_rfq_generate by naming the exact deliverable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description establishes when the tool is appropriate by defining the deliverable and its mandatory elements. It also cautions that the disposition decision belongs to the responsible quality authority, implying the tool assists but does not decide. However, it does not explicitly say when not to use it or name alternatives, though siblings are contextually different.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_pdf_markupBluebeam PDF Markup WriterAInspect
Add real Bluebeam-compatible annotation objects to a drawing PDF — counts, length/area measurements with live scales, RFI clouds, callouts — from a markups JSON you supply plus placement coordinates. Pass the PDF as an https URL or small base64; returns a marked PDF download link that expires within ~48 hours. Markups appear in Bluebeam Revu's Markups List. You decide placement; the tool guarantees the format. Nothing you submit is stored.
| Name | Required | Description | Default |
|---|---|---|---|
| scale | No | Document scale for measurements, e.g. "1/4 in = 1 ft" or "1:100" | |
| author | No | Markups List author column | |
| markups | Yes | Markups to place — geometry in ratio (0–1 from top-left) or pdf coordinates | |
| pdf_url | No | HTTPS URL of the source drawing PDF (fetched server-side, SSRF-guarded) | |
| pdf_base64 | No | Base64 PDF for small files (~3 MB max decoded); prefer pdf_url for drawing sets | |
| page_scales | No | Per-page scale overrides, keyed by page number string | |
| coordinate_space | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses important behaviors: the output is a download link expiring in ~48 hours, markups appear in Bluebeam Revu's Markups List, the user controls placement while the tool ensures format, and nothing submitted is stored. It does not detail edge cases like what happens on invalid PDFs, but the disclosed behaviors are useful and non-obvious.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences but packs in essential info: annotation types, input format, PDF input methods, return format, expiration, Bluebeam compatibility, placement control, and privacy. Every phrase carries meaning; no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (nested markups array, coordinate spaces, multiple parameter options, no output schema), the description covers the key inputs, the return link, expiration, and privacy. It does not explain coordinate-space semantics, but the schema provides that detail, so the description is complete enough for an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high (86%), so the schema already documents most parameters. The description adds the concept of a 'markups JSON' and 'placement coordinates', but it does not go beyond the schema for individual parameters. This meets the baseline 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Add') with a clear resource ('real Bluebeam-compatible annotation objects to a drawing PDF') and enumerates example annotation types (counts, length/area measurements, RFI clouds, callouts). This clearly distinguishes it from the sibling steel calculation/reference tools, which have entirely different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly explains the input format ('markups JSON you supply plus placement coordinates'), how to pass the PDF (https URL or base64), and even gives a preference hint ('prefer pdf_url for drawing sets'). It does not explicitly state when to use this vs. alternatives, but the sibling tools are so different that the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_pipe_schedulePipe Schedule LookupAInspect
Steel pipe dimensions by NPS and schedule: OD, wall, inside diameter and lb/ft for schedules 5, 10, 40/STD, 80/XS, 160 and XXS. Omit the schedule to list them all. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| nps | Yes | Nominal pipe size, e.g. "2", "1/2", "1-1/4" | |
| schedule | No | Optional schedule: "40", "80", "160", "STD", "XS", "XXS", "5", "10" |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that values are 'published nominal values for estimating and orientation, not design guidance,' which is important behavioral context. It also states the output fields, providing transparency for a lookup tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and output fields, followed by usage instruction and caveat. Every sentence earns its place with no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple lookup tool with no output schema, the description sufficiently covers return fields (OD, wall, inside diameter, lb/ft), available schedules, and usage variations. It is complete enough for an agent to correctly invoke the tool without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents both parameters. The description adds the tip about omitting the schedule to list all, but this is more usage guidance than parameter semantics. It does not provide additional format or meaning beyond what the schema gives.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it provides steel pipe dimensions by NPS and schedule, listing specific attributes (OD, wall, inside diameter, lb/ft). It distinguishes itself from sibling tools by focusing on pipe schedule lookup, which is unique among the provided siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage context: 'Omit the schedule to list them all' explains how to vary the query. However, it does not explicitly mention alternatives or conditions when not to use this tool, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_plate_weightSteel Plate WeightAInspect
Compute carbon steel plate weight from thickness (decimal or fraction) and width/length in inches, with optional material cost via price_per_lb. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| width_in | Yes | Plate width in INCHES (a 4x8 ft plate is 48 x 96 in) | |
| length_in | Yes | Plate length in INCHES | |
| price_per_lb | No | Optional material price in $/lb, to include a cost estimate | |
| thickness_in | Yes | Plate thickness in inches — decimal or fraction ("3/4", "1-1/8") |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It adds useful caveats about nominal values and design limitations, but does not disclose output format, rounding behavior, or material density assumptions beyond 'carbon steel'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: the first front-loads the action and key inputs, the second adds the caveat. Every word earns its place, with no unnecessary detail or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple calculation tool with no output schema, the description covers purpose, inputs, and limitations. It does not explicitly state the output unit (pounds), but this is strongly implied by 'price_per_lb' and the domain. Slightly more detail on output would make it fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema—it restates that thickness can be decimal or fraction and that price_per_lb is optional, but these are already in the parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool computes carbon steel plate weight from thickness, width, and length in inches, with optional cost via price_per_lb. This specific verb+resource+inputs distinguishes it from sibling tools like steel_shape_weight, which targets structural shapes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context that values are nominal, for estimating and orientation, not design guidance. However, it does not explicitly mention when to use this tool versus alternatives like steel_shape_weight or steel_gauge_thickness, so it lacks explicit exclusions or alternative references.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_rfi_generateRFI Document GeneratorAInspect
Generate a formal Request for Information PDF from structured fields — header, meta grid, subject, description, proposed solution, attachments, and a blank response block for the design team. You do the judgement (one issue per RFI, exact drawing references, a proposed path forward); the tool guarantees the format. Returns a download link that expires within ~48 hours. Nothing you submit is stored.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | Submission date | |
| reason | No | Category: Design Omission, Design Error, Constructability Issue, Scope Clarification, Site Condition, Missing Information, Coordination Conflict — or free text | |
| subject | Yes | One-line subject — one issue per RFI | |
| spec_refs | No | ||
| rfi_number | Yes | RFI number from the project register, e.g. "RFI-017" | |
| attachments | No | ||
| description | Yes | The issue: specific references, what is missing or conflicting, why it matters. Newlines respected. | |
| company_name | Yes | Contractor issuing the RFI — appears in the header | |
| drawing_refs | No | Exact drawing numbers with revisions | |
| project_name | Yes | ||
| submitted_by | Yes | Name — company | |
| submitted_to | Yes | The party who must respond — engineer, architect, GC | |
| project_number | No | ||
| company_location | No | ||
| proposed_solution | No | Suggested path forward, framed as a proposal | |
| response_needed_by | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the output is a PDF, details the return as a 'download link that expires within ~48 hours,' and explicitly says 'Nothing you submit is stored.' It also defines the division of labor between the agent (judgment) and the tool (format). This is substantive, non-redundant transparency that goes well beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of three sentences, each adding unique value: the core purpose and structure, the expectation of user judgment, and the transient/storage behavior. There is no repetition of schema details and no filler. The most critical information (what it generates) is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 16 parameters, no output schema, and no annotations, this description is appropriately complete. It covers what the tool produces, the sections it contains, how it behaves (link expiry, no storage), and the user's responsibility. It does not mention error conditions, prerequisites, or alternative tools, but those are not critical for a PDF generator. The schema covers the parameter details, so the description fills behavioral gaps effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 63% of parameters, so the description does not need to fully enumerate them, but it compensates by mapping the logical document structure (header, meta grid, subject, description, proposed solution, attachments) to input fields. The guidance about 'exact drawing references' and 'a proposed path forward' clarifies the intended semantics for drawing_refs, proposed_solution, and attachments. However, some schema-uncovered parameters (e.g., response_needed_by, company_location) are not addressed, leaving a minor gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Generate a formal Request for Information PDF from structured fields,' which is a specific verb+resource combination. It further clarifies scope by listing the included sections (header, meta grid, subject, description, proposed solution, attachments, response block) and explicitly differentiates the tool's role as a formatter, not a content creator. Although it does not name sibling tools, 'RFI' in both name and description is unmistakably distinct from NCR/RFQ generators.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage context: 'You do the judgement (one issue per RFI, exact drawing references, a proposed path forward); the tool guarantees the format.' This implies the appropriate workflow—prepare content, let the tool handle formatting—but does not explicitly state when to use this tool versus alternatives (e.g., steel_ncr_generate or steel_rfq_generate). No exclusions or when-not conditions are provided, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_rfq_generateRFQ Workbook GeneratorAInspect
Generate a vendor-ready Request for Quotation (.xlsx) from structured takeoff line items — grouped by material, with vendor pricing columns, totals and standard terms. You pass parsed line items and a company name; returns a download link that expires within ~48 hours. Nothing you submit is stored.
| Name | Required | Description | Default |
|---|---|---|---|
| terms | No | Override the eight default terms; omit for the standard set | |
| line_items | Yes | Parsed takeoff line items — the calling agent reads the estimate | |
| date_issued | No | Free-form issue date; a blank line is used if omitted | |
| company_name | Yes | Buyer company on the RFQ header and terms — required | |
| nesting_rows | No | Optional fabricator-facing nesting/drop reference rows | |
| project_name | Yes | Project name for the header and filename | |
| company_location | No | City, state under the company name, e.g. "Denver, CO" | |
| project_location | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that a download link expires within ~48 hours and that nothing submitted is stored, which is valuable behavioral and privacy context. This goes beyond the schema's capabilities.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action, and efficiently packs in output details, input requirements, expiry behavior, and privacy. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the essential workflow: input (parsed line items, company name), output (download link with expiry), and content (grouping, pricing columns, terms). Since there is no output schema, this return-value description is important and it is provided. The schema handles parameter details, so the combination is quite complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high at 88%, so the baseline is 3. The description adds high-level pointers to line items and company name but doesn't explain individual parameters beyond what the schema already documents. It does not compensate for the small unexplained gap, but the schema carries most of the weight.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with 'Generate a vendor-ready Request for Quotation (.xlsx)' – a specific verb, resource, and format. It further clarifies the output structure (grouped by material, vendor pricing columns, totals, standard terms) and clearly distinguishes from all sibling tools, none of which generate RFQs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states 'You pass parsed line items and a company name', providing clear input context. It doesn't explicitly name alternatives, but no sibling tool performs a similar function, so the guidance is adequate. The mention of 'standard terms' also implies a default use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_section_weightBar & Tube Section WeightAInspect
Weight of round bar, square bar, flat bar or round tube from dimensions in inches — lb/ft and optional piece weight, in carbon, stainless or aluminum. For AISC designations use steel_shape_weight; for plate use steel_plate_weight. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| dim1_in | Yes | First dimension in inches: diameter (round bar), side (square bar), width (flat bar) or OD (round tube) | |
| dim2_in | No | Second dimension in inches: thickness (flat bar) or wall (round tube); unused for round and square bar | |
| section | Yes | Cross-section type | |
| material | No | Default carbon steel; stainless is +2%, aluminum ×0.35 | |
| length_ft | No | Optional length in feet for a piece weight |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses that values are 'published nominal' and not for design, which is a key behavioral caveat. It also specifies output modes (per-ft and optional piece weight). It does not disclose rounding or error handling, but the caveat is significant.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core purpose, then alternatives and caveat. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers materials, output units, and usage limitations. Without an output schema, it still specifies what the result is ('lb/ft and optional piece weight'). Minor gap: it doesn't warn that dim2 is required for flat/tube, which might be inferred from schema. Overall adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already defines all parameters. The description adds context about output units and the relationship between dimensions and section types, but most parameter meaning is already in the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the exact resource ('round bar, square bar, flat bar or round tube'), the action ('Weight of'), and the output ('lb/ft and optional piece weight'). It also distinguishes itself from siblings by explicitly naming alternative tools for other shapes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit alternative tool names ('For AISC designations use steel_shape_weight; for plate use steel_plate_weight') and clarifies the intended use case ('for estimating and orientation, not design guidance').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_shape_weightStructural Shape WeightAInspect
Look up an AISC shape designation (W, C, MC, L, HSS, PIPE) for lb/ft, depth and area, with optional piece weight. 14th-Edition-era data. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| qty | No | Optional piece count | |
| length_ft | No | Optional piece length in feet, for a piece weight | |
| designation | Yes | AISC designation, e.g. "W21X50", "HSS6X6X3/8", "L4X4X3/8" |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so description carries burden. It discloses data source (14th-Edition-era), values are nominal, and not design guidance. This clarifies the tool's safety profile and limitations, though it doesn't describe error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, directly front-loaded with the action and outputs, no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers purpose, inputs, outputs, and limitations. Since there is no output schema, it still specifies what fields are returned. It doesn't explicitly contrast with siblings, but the shape list provides enough differentiation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with descriptions for all three parameters. Description adds no param detail, but baseline is 3 for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb 'Look up' with resource 'AISC shape designation' and lists outputs (lb/ft, depth, area). It distinguishes from sibling steel_plate_weight by naming shape types (W, C, MC, L, HSS, PIPE).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states use case (estimating and orientation) and explicitly excludes design guidance. It doesn't name alternatives, but the shape list implies the scope, providing enough context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
steel_takeoff_weightTakeoff Weight Roll-UpAInspect
Roll a member list (AISC designation, length in feet, piece count — up to 500 lines) into a bill-of-steel ledger: weight per line, total pounds and tons, piece and lineal-foot counts. Net weight only; unmatched designations are listed, not guessed. Published nominal values for estimating and orientation, not design guidance.
| Name | Required | Description | Default |
|---|---|---|---|
| members | Yes | The member list to roll up, one line per mark/size |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden and does well: it discloses that weights are published nominal values, that unmatched designations are listed rather than guessed, and that the output is for estimating/orientation only. This gives users a clear behavioral model beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action and contains no filler. Every phrase contributes value: inputs, limit, outputs, matching behavior, and use-case caveat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the moderate complexity of a nested array input and no output schema, the description adequately covers what the tool returns (weight per line, totals, counts) and edge behavior (unmatched designations). It lacks explicit error-handling details but is otherwise complete for an estimating tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents the single 'members' parameter and its nested fields (designation, length_ft, qty) with examples. The description adds useful context like 'up to 500 lines' (already in schema as maxItems) and clarifies units (feet, pounds, tons), but does not materially extend the parameter documentation since coverage is 100%.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Roll') and identifies the resource ('member list') and output ('bill-of-steel ledger'), clearly distinguishing it from sibling tools that compute individual weights or plate/section weights. It also specifies the key inputs (AISC designation, length, piece count) and outputs (weight per line, totals, counts).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: for batch member-list takeoffs to produce a ledger, not for design calculations. It also states limitations ('net weight only', 'unmatched designations are listed, not guessed'), which helps guide appropriate use. It does not explicitly name alternative sibling tools, but the batch vs. single-item distinction is implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Frequently Asked Questions
Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity — fastest for official registry listings. For a namespace such as
io.github.alice/server, link the matching GitHub user or an account that owns the GitHub organization, then choose Claim with GitHub.HTTP challenge — works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at
/.well-known/glama.jsonon the same origin as the connector, then choose Check HTTP challenge.DNS challenge — works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Connectors
Auditable construction takeoffs with locked waste and conservative purchase rounding.
5,400+ manufacturing calculators plus live U.S. tariff, PMI, cost-index, wage, and forecast data.
Construction takeoff and estimating for AI agents. Measure a drawing PDF, export a priced estimate.
27 engineering compliance and calculation tools for the built environment (UK, EU, UAE).
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables construction teams to create local projects, record sourced field evidence, run deterministic quantity calculations, and draft daily logs, estimates, and change orders with visible assumptions and human approval gates. Keeps all data local and portable with no external side effects.10Apache 2.0

RoofMeasure MCPofficial
AlicenseAqualityBmaintenanceProvides free EagleView-style satellite roof measurements and modular Xactimate-style estimating from Google Solar API data, enabling contractors to generate reports and estimates from any address.3MIT- AlicenseAqualityBmaintenanceProvides professional-grade data center engineering calculations including cooling, power, GPU thermal optimization, UPS/battery sizing, tier classification, and commissioning workflows, compliant with ASHRAE and Uptime Institute standards.8171MIT
- FlicenseNot gradedqualityDmaintenanceProvides construction cost estimation tools using data from a public Google Sheet for items like concrete, framing, and electrical. It allows users to search items, filter by category, and calculate total project costs including labor and material expenses.