# Connecting ETABS & SAP2000
Source: https://docs.stru.ai/desktop-app/connect-etabs-sap2000
Let the Stru AI agents build and analyze models in the SAP2000 and ETABS installed on your machine
## How the Connection Works
Once you're signed in, the desktop app runs a local **Client** that bridges your conversations to the SAP2000 and ETABS installed on your machine. The agent sends modeling commands; the software executes them live on your screen.
The **Client** pill in the header shows the connection at a glance:
| Status | What it means |
| ---------------- | --------------------------------------------------------------- |
| **Gray dot** | Client isn't running yet |
| **Pulsing gray** | Downloading or starting (normal for a few seconds after launch) |
| **Green dot** | Connected and ready to drive SAP2000/ETABS |
| **Error** | Something failed. Restart the client from this menu. |
Click the pill for **Start client**, **Stop client**, and **Restart client**. The client starts on its own shortly after you sign in. You rarely need to touch it.
The web app's ETABS and SAP2000 agents use this same connection. To run those agents from [app.stru.ai](https://app.stru.ai), keep the desktop app open and signed in on the machine where the software is installed.
## Start a Modeling Session
Choose **SAP2000 Agent** or **ETABS Agent** from the agent picker in the header. The choice locks once the conversation starts. Start a new chat to switch.
The **working folder** pill on the composer decides where model files live: **This chat only** keeps everything in the conversation's own sandbox, or pick a shared project folder so multiple conversations can work on the same files.
Prompt the agent the same way you would on the web: geometry, sections, materials, load cases. See [Writing Effective Prompts](/platform-guides/etabs-sap2000-agents#writing-effective-prompts) for what works best.
SAP2000/ETABS opens and builds on your screen while the chat shows live progress: the status bar, a step-by-step plan that ticks off as the agent works, and a lane badge (**SAP busy**, **SAP ready**, or the ETABS equivalent) showing the live software connection.
Long builds can hit the per-turn step limit. The status bar shows **Agent paused** with a **Resume** link. Click it to continue right where it left off. You can raise the limit under **Settings → Agents → Agent step limit**.
The app auto-detects SAP2000, ETABS, and Mathcad installed in their default locations and uses the newest version it finds. If you have several versions installed, pick the one you want under **Settings → SAP2000 / ETABS**. Each tab shows its detected-versions list with a refresh action.
## Good to Know
If SAP2000/ETABS is running under Stru's control when you quit (or install an update), the app asks for confirmation, because continuing closes that software session too. Save your model first if it matters.
**Settings → General → Pre-warm SAP2000 and ETABS on app launch** starts the software connection as soon as the app opens, so your first prompt doesn't wait on startup.
The desktop app connects to Stru AI each time it starts and during agent runs. If the connection drops, the app shows a reconnect screen and resumes automatically. You're never signed out for being offline.
## Next Steps
Prompting patterns, use cases, and troubleshooting for the agents themselves.
Fix detection issues, update problems, and more.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Install & Sign In
Source: https://docs.stru.ai/desktop-app/install-and-sign-in
Set up the Stru AI Desktop Client on your Windows machine and pair it with your Stru AI account
## What the Desktop App Is
The **Stru AI Desktop Client** connects your Stru AI account to the engineering software already installed on your machine. With the desktop app running, the ETABS and SAP2000 agents build and analyze models directly in your own licensed copies of the software, on your hardware, with your files.
Drives the SAP2000, ETABS, and Mathcad installations you already own. Nothing extra to license.
One sign-in connects the desktop app to the same conversations, files, and agents as [app.stru.ai](https://app.stru.ai)
## Requirements
* **Windows** with SAP2000 and/or ETABS installed in their default locations (`C:\Program Files\Computers and Structures\...`)
* A **Stru AI account**
* An **internet connection**: the app connects to Stru AI each time it starts
macOS support is on the way. Today, agent-driven SAP2000/ETABS work runs on Windows.
## Install
Download the latest **Stru AI Desktop Client Setup** (`.exe`) from the releases page.
Run the downloaded file and follow the prompts. The app launches when installation completes.
On first launch, the app prepares its working environment automatically. You'll see a **"Setting up your environment"** progress screen. This one-time step typically takes about a minute.
If setup can't finish (for example, the connection dropped), restart the app. It picks up and retries automatically.
## Sign In
The app opens your default browser to authorize the sign-in.
If you're already signed in at [app.stru.ai](https://app.stru.ai), authorization is instant. Otherwise, sign in as usual. The browser shows a confirmation page when the desktop app is authorized.
The desktop app picks up the sign-in automatically, with no codes to copy. You land directly in the chat workspace.
The sign-in window stays open for 5 minutes. If it lapses, or the browser never returned to the confirmation page, click **Try Again** in the app and complete the browser step again.
Sign out from **Settings → General → Account → Logout**. If the app returns you to the sign-in screen on its own (for example, after an extended time away), sign in again. Your conversations and settings are safe.
## Staying Up to Date
Updates download automatically in the background. When one is ready, an **Update** button appears in the header. Click it and the app restarts on the new version in a few seconds. You can also check your current version anytime under **Settings → Software → Check for updates**.
If SAP2000 or ETABS is running under Stru's control when you update or quit, the app asks for confirmation first, because updating closes that session. Save your model in SAP2000/ETABS before continuing. If you don't respond, the app proceeds automatically after about 10 seconds.
## Next Steps
Start your first agent-driven modeling session.
Tune the app and fix common hiccups.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Settings & Troubleshooting
Source: https://docs.stru.ai/desktop-app/settings-and-troubleshooting
Tune the Stru AI Desktop Client to your workflow and resolve common issues
## Settings Tour
Open Settings from the **gear icon** (or your profile) in the header.
### General: appearance, dictation, and account
* **Theme** (Light/Dark) and **Palette** color presets.
* **Design standard**: the default building-code region for your conversations (US, Eurocode, Australia/NZ, Canada, Philippines, Singapore).
* **Dictation**: pick which microphone the composer's voice input uses.
* **Account**: your signed-in profile, your usage meter, and **Logout**.
* **Reset Configuration**: clears preferences, working directories, and environment paths, but keeps you signed in.
### Agents: how runs behave
* **Show advanced stats**: adds elapsed time and step count to the status bar.
* **Agent step limit**: how many steps a run takes before pausing for your go-ahead.
* **Enter while agent is working**: choose whether a mid-run message **steers** the current response or **queues** for after it finishes.
* **Live thought panel**: show just the latest reasoning or the full log.
* **Formatting standards**: point the agent at your [standards folder](/how-to/standards-folder) so deliverables follow your templates.
### SAP2000, ETABS & MathCAD: software and folders
Each tab shows a **working directory** picker and the **detected versions** of that software with a refresh action. Select which version the agent should use if you have more than one. The MathCAD tab adds toggles to auto-open generated files and to overwrite files when editing.
### Software: version and updates
Shows the app's current version, a **Check for updates** button, and live update status. When an update has downloaded, **Update now** installs it with a quick restart.
### Python: the app's environment
The app manages its environment automatically. If needed, this tab lets you auto-detect an installation, pick from the ones it found, or download and install a fresh one with one click.
## Troubleshooting
Click **Continue** to launch anyway. If it keeps happening, click **Open download page** and run the latest installer over your existing install. That resolves a stuck update in one step.
Close and reopen the app. Setup resumes automatically. Check that your internet connection (or firewall) isn't blocking downloads. If it fails repeatedly, reinstall with the latest installer.
Reopen it from its icon. It resumes on the new version. If it truly won't open, run the latest full installer from the download page over the existing install.
Make sure the desktop app is **open and signed in** on the Windows machine with the software installed, and the **Client** pill is green. If you recently switched accounts, fully quit and reopen the desktop app once, then retry.
The app detects software in the default install locations (`C:\Program Files\Computers and Structures\...`). Click the refresh action in **Settings → SAP2000 / ETABS**, then select the right version from the list.
Normal for a few seconds after launch while the client starts. If it stays gray past a minute, check your internet connection and choose **Restart client** from the pill's menu, or restart the app.
**Out of credits** means you've hit your usage limit. The banner shows when it resets, and your live balance is under **Settings → General → Account**. **Response interrupted** means the run stopped early. Hit retry or send the message again.
## Sending Logs to Support
If support asks for logs, zip and attach this folder from your Windows user profile:
```text theme={null}
%APPDATA%\structures-ai\logs\
```
Paste that path into the File Explorer address bar and press Enter to jump straight to it.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Drawing Analysis API
Source: https://docs.stru.ai/drawing-api/overview
AI-powered construction drawing analysis with structured data extraction and semantic search
Analyze construction drawings with AI. Extract annotations, build knowledge graphs, and search across entire drawing sets.
```python Python theme={null}
from struai import StruAI
client = StruAI(api_key="YOUR_API_KEY")
result = client.drawings.analyze("structural.pdf", page=4)
print(result.annotations.leaders)
```
```bash cURL theme={null}
curl -X POST https://api.stru.ai/v1/drawings \
-H "Authorization: Bearer YOUR_API_KEY" \
-F "file=@structural.pdf" \
-F "page=4"
```
**Built for:** AEC firms, software integrators, document management platforms, and startups building on drawing intelligence.
***
## Get Started
```bash theme={null}
pip install struai
```
Requires Python 3.9+
Get an API key from [app.stru.ai](https://app.stru.ai), then set it as an environment variable:
```bash theme={null}
export STRUAI_API_KEY="YOUR_API_KEY"
```
```python Python theme={null}
import os
from struai import StruAI
client = StruAI(api_key=os.environ["STRUAI_API_KEY"])
result = client.drawings.analyze("drawing.pdf", page=1)
# Access detected annotations
for leader in result.annotations.leaders:
print(f"Found: {leader.texts_inside}")
```
```bash cURL theme={null}
curl -X POST https://api.stru.ai/v1/drawings \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-F "file=@drawing.pdf" \
-F "page=1"
```
***
## Capabilities
Fast geometric detection returning results in 1-2 seconds. No LLM processing, no graph storage.
**Detects:** Leaders, Section Tags, Detail Tags, Revision Triangles, Revision Clouds, Title Block bounds.
```python Python theme={null}
result = client.drawings.analyze("structural.pdf", page=4)
# File hash caching skips re-uploads
from struai import compute_file_hash
file_hash = compute_file_hash("structural.pdf")
# Check cache before uploading
cached = client.drawings.check_cache(file_hash)
```
```bash cURL theme={null}
# Analyze with file upload
curl -X POST https://api.stru.ai/v1/drawings \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-F "file=@structural.pdf" \
-F "page=4"
# Or check cache by file hash
curl https://api.stru.ai/v1/drawings/cache/{file_hash} \
-H "Authorization: Bearer $STRUAI_API_KEY"
```
**Price:** \$0.02/page
Full pipeline: detection → LLM enrichment → knowledge graph → semantic search.
**What you get:**
* Entities with semantic descriptions
* Relationships between entities
* Cross-sheet reference linking
* Natural language search
```python Python theme={null}
# Create a project
project = client.projects.create(name="Building A Structural")
# Ingest multiple pages at once
jobs = project.sheets.add("structural.pdf", page="1-10")
# Search with natural language
results = project.search("W12x26 beam connections")
```
```bash cURL theme={null}
# Create project
curl -X POST https://api.stru.ai/v1/projects \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"name": "Building A Structural"}'
# Ingest multiple pages
curl -X POST https://api.stru.ai/v1/projects/proj_xxx/sheets \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-F "file=@structural.pdf" \
-F "page=1-10"
```
| Operation | Price |
| --------------- | ------------- |
| Graph Ingestion | \$0.15/page |
| Search | \$0.005/query |
Use `AsyncStruAI` for non-blocking operations in async applications.
```python theme={null}
import asyncio
from struai import AsyncStruAI
async def analyze_drawings():
client = AsyncStruAI(api_key="YOUR_API_KEY")
result = await client.drawings.analyze("drawing.pdf", page=1)
return result
asyncio.run(analyze_drawings())
```
***
## Use Cases
Automatically link section tags, detail callouts, and sheet references across a drawing set
Validate drawing consistency, detect missing references, flag revision conflicts
Extract and count components, connections, and annotations
Build structured data for BIM/analysis workflows
***
## API Reference
### Authentication
All requests require a Bearer token:
```python Python theme={null}
from struai import StruAI
client = StruAI(api_key="YOUR_API_KEY")
# Or use environment variable
client = StruAI() # Uses STRUAI_API_KEY
```
```bash cURL theme={null}
Authorization: Bearer
```
***
### Tier 1: Raw Detection
Fast geometric detection. No LLM, no graph storage. Returns annotations in 1-2 seconds.
**Price:** \$0.02/page
#### GET /v1/drawings/cache/
Check whether a PDF file hash exists in the drawing cache.
```bash theme={null}
curl https://api.stru.ai/v1/drawings/cache/{file_hash} \
-H "Authorization: Bearer $STRUAI_API_KEY"
```
Returns cache metadata when the file hash is found.
#### POST /v1/drawings
Submit a PDF page for annotation detection.
| Field | Type | Required | Description |
| ----------- | ------- | ---------------------------- | --------------------------------- |
| `file` | file | One of `file` or `file_hash` | PDF file (max 50MB) |
| `file_hash` | string | One of `file` or `file_hash` | Hash of a previously uploaded PDF |
| `page` | integer | Yes | Page number (1-indexed) |
```python Python theme={null}
result = client.drawings.analyze("structural.pdf", page=4)
# Access annotations
print(result.annotations.leaders)
print(result.annotations.section_tags)
print(result.annotations.detail_tags)
```
```bash cURL theme={null}
curl -X POST https://api.stru.ai/v1/drawings \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-F "file=@structural.pdf" \
-F "page=4"
```
```json theme={null}
{
"id": "drw_7f8a9b2c",
"page": 4,
"dimensions": {"width": 2592, "height": 1728},
"processing_ms": 1250,
"annotations": {
"leaders": [
{
"id": "ldr_001",
"bbox": [1200, 450, 1400, 520],
"arrow_tip": [1200, 485],
"text_bbox": [1280, 450, 1400, 520],
"texts_inside": [{"id": 45, "text": "W12x26"}]
}
],
"section_tags": [
{
"id": "sec_001",
"bbox": [800, 600, 850, 650],
"circle": {"center": [825, 625], "radius": 22},
"direction": "right",
"texts_inside": [{"id": 12, "text": "A"}, {"id": 13, "text": "S1.5"}],
"section_line": {"start": [200, 625], "end": [800, 625]}
}
],
"detail_tags": [
{
"id": "det_001",
"bbox": [1500, 900, 1550, 950],
"circle": {"center": [1525, 925], "radius": 22},
"texts_inside": [{"id": 78, "text": "3"}, {"id": 79, "text": "S1.6"}],
"has_dashed_bbox": true
}
],
"revision_triangles": [
{
"id": "tri_001",
"bbox": [600, 300, 620, 330],
"vertices": [[610, 300], [600, 330], [620, 330]],
"text": "B"
}
],
"revision_clouds": [
{
"id": "cld_001",
"bbox": [400, 200, 700, 450]
}
]
},
"titleblock": {
"bounds": [2100, 50, 2550, 1700],
"viewport": [50, 50, 2100, 1700]
}
}
```
#### GET /v1/drawings/
Retrieve a previously processed drawing.
```python theme={null}
result = client.drawings.get("drw_7f8a9b2c")
```
#### DELETE /v1/drawings/
Delete a drawing result.
```python theme={null}
client.drawings.delete("drw_7f8a9b2c")
```
***
### Tier 2: Graph + Search
Full pipeline: detection → LLM enrichment → knowledge graph → semantic search.
**What you get:**
* Entities with semantic descriptions
* Relationships between entities
* Cross-sheet reference linking
* Natural language search
| Operation | Price |
| --------------- | ------------- |
| Graph Ingestion | \$0.15/page |
| Search | \$0.005/query |
#### POST /v1/projects
Create a project to group related sheets.
```python Python theme={null}
project = client.projects.create(
name="Building A Structural",
description="96-page structural drawing set"
)
```
```bash cURL theme={null}
curl -X POST https://api.stru.ai/v1/projects \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"name": "Building A Structural"}'
```
```json theme={null}
{
"id": "proj_abc123",
"name": "Building A Structural",
"description": "96-page structural drawing set",
"created_at": "2026-01-29T10:00:00Z"
}
```
#### GET /v1/projects
List all projects.
```json theme={null}
{
"projects": [
{
"id": "proj_abc123",
"name": "Building A Structural",
"description": "96-page structural drawing set",
"created_at": "2026-01-29T10:00:00Z"
}
]
}
```
#### GET /v1/projects/
Get project details and aggregate stats.
```json theme={null}
{
"id": "proj_abc123",
"name": "Building A Structural",
"description": "96-page structural drawing set",
"created_at": "2026-01-29T10:00:00Z",
"sheet_count": 12,
"entity_count": 847,
"rel_count": 392,
"community_count": 8
}
```
#### DELETE /v1/projects/
Delete project and all associated graph data.
```json theme={null}
{"deleted": true, "id": "proj_abc123"}
```
***
### Sheets
#### POST /v1/projects//sheets
Ingest one or more PDF pages into the knowledge graph. Returns immediately with job IDs for polling.
| Field | Type | Required | Description |
| ---------------------------- | ------ | ---------------------------- | --------------------------------------------------------------------------- |
| `file` | file | One of `file` or `file_hash` | PDF file |
| `file_hash` | string | One of `file` or `file_hash` | Hash of a previously uploaded PDF |
| `page` | string | Yes | Page selector (see formats below) |
| `source_description` | string | No | Description of the source document |
| `on_sheet_exists` | string | No | Behavior when sheet already exists: `error`, `skip` (default), or `rebuild` |
| `community_update_mode` | string | No | `incremental` or `rebuild` |
| `semantic_index_update_mode` | string | No | `incremental` or `rebuild` |
**Page selector formats:**
| Format | Example | Description |
| ------------ | ---------- | -------------------------------- |
| Single page | `12` | One specific page |
| Range | `1-5` | Inclusive page range |
| List / mixed | `1,3,8-10` | Comma-separated pages and ranges |
| All pages | `all` | Every page in the PDF |
```python Python theme={null}
# Single page
job = project.sheets.add("structural.pdf", page="1")
# Range of pages
jobs = project.sheets.add("structural.pdf", page="1-10")
# Mixed selection
jobs = project.sheets.add("structural.pdf", page="1,3,8-10")
# All pages
jobs = project.sheets.add("structural.pdf", page="all")
# With options
jobs = project.sheets.add(
"structural.pdf",
page="1-5",
on_sheet_exists="rebuild"
)
```
```bash cURL theme={null}
# Single page
curl -X POST https://api.stru.ai/v1/projects/proj_xxx/sheets \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-F "file=@structural.pdf" \
-F "page=1"
# Range of pages
curl -X POST https://api.stru.ai/v1/projects/proj_xxx/sheets \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-F "file=@structural.pdf" \
-F "page=1-10"
# With options
curl -X POST https://api.stru.ai/v1/projects/proj_xxx/sheets \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-F "file=@structural.pdf" \
-F "page=all" \
-F "on_sheet_exists=skip"
```
One job is created per page:
```json theme={null}
{
"jobs": [
{"job_id": "job_abc123def4", "page": 1},
{"job_id": "job_abc123def5", "page": 2},
{"job_id": "job_abc123def6", "page": 3}
]
}
```
#### GET /v1/projects//jobs/
Poll job status for async sheet ingestion. Each job progresses through a 5-step pipeline.
**Pipeline steps:**
| Step | Key | Description |
| ---- | ---------------------------- | -------------------------- |
| 1/5 | `detect_annotations` | Detect Annotations |
| 2/5 | `enrich_annotations` | Enrich Annotations |
| 3/5 | `synthesize_remaining_text` | Synthesize Remaining Text |
| 4/5 | `resolve_entities_and_facts` | Resolve Entities and Facts |
| 5/5 | `load_graph_and_index` | Load Graph and Index |
**Job statuses:** `queued` → `running` → `complete` | `failed`
**Timeout rules:**
* Queued timeout: 30 minutes from enqueue
* Running timeout: 10 minutes from first start
```json theme={null}
{
"job_id": "job_abc123def4",
"status": "running",
"created_at_utc": "2026-02-08T19:40:10.112Z",
"started_at_utc": "2026-02-08T19:40:10.220Z",
"completed_at_utc": null,
"status_log": [
{
"seq": 1,
"event": "queued",
"status": "queued",
"at_utc": "2026-02-08T19:40:10.112Z",
"message": "Queued"
},
{
"seq": 2,
"event": "step_started",
"status": "running",
"at_utc": "2026-02-08T19:40:10.220Z",
"step": {
"key": "detect_annotations",
"index": 1,
"total": 5,
"label": "Step 1/5: Detect Annotations"
},
"message": "Step 1/5: Detect Annotations started"
},
{
"seq": 3,
"event": "step_completed",
"status": "running",
"at_utc": "2026-02-08T19:40:14.031Z",
"step": {
"key": "detect_annotations",
"index": 1,
"total": 5,
"label": "Step 1/5: Detect Annotations"
},
"message": "Step 1/5: Detect Annotations completed"
},
{
"seq": 4,
"event": "step_started",
"status": "running",
"at_utc": "2026-02-08T19:40:14.033Z",
"step": {
"key": "enrich_annotations",
"index": 2,
"total": 5,
"label": "Step 2/5: Enrich Annotations"
},
"message": "Step 2/5: Enrich Annotations started"
}
]
}
```
```json theme={null}
{
"job_id": "job_abc123def4",
"status": "complete",
"created_at_utc": "2026-02-08T19:40:10.112Z",
"started_at_utc": "2026-02-08T19:40:10.220Z",
"completed_at_utc": "2026-02-08T19:41:45.800Z",
"status_log": ["..."],
"result": {
"sheet_id": "S1.4",
"entities_created": 87,
"relationships_created": 42,
"skipped": false,
"sheet_exists_mode": "skip",
"community_mode": "incremental",
"semantic_index_mode": "incremental"
}
}
```
```json theme={null}
{
"job_id": "job_abc123def4",
"status": "failed",
"created_at_utc": "2026-02-08T19:40:10.112Z",
"started_at_utc": "2026-02-08T19:40:10.220Z",
"completed_at_utc": "2026-02-08T19:40:22.500Z",
"status_log": ["..."],
"error": {
"code": "step_failed",
"message": "Enrichment timed out"
}
}
```
#### GET /v1/projects//sheets
List all ingested sheets in a project.
```json theme={null}
{
"project_id": "proj_abc123",
"sheets": [
{
"id": "S1.4",
"sheet_uuid": "uuid_xxx",
"title": "LEVEL 1 FOUNDATION PLAN",
"revision": "A",
"page": 12,
"width": 2592,
"height": 1728,
"mention_count": 45,
"component_instance_count": 23,
"region_count": 6,
"created_at": "2026-02-08T19:41:45.800Z"
}
]
}
```
#### GET /v1/projects//sheets/
Get full sheet graph slice including regions, mentions, component instances, and references.
```json theme={null}
{
"id": "S1.4",
"sheet_uuid": "uuid_xxx",
"title": "LEVEL 1 FOUNDATION PLAN",
"regions": ["..."],
"mentions": ["..."],
"component_instances": ["..."],
"references": ["..."]
}
```
#### GET /v1/projects//sheets//annotations
Get the raw annotation geometry from cached detection results for a processed sheet.
```bash theme={null}
curl https://api.stru.ai/v1/projects/proj_xxx/sheets/S1.4/annotations \
-H "Authorization: Bearer $STRUAI_API_KEY"
```
```json theme={null}
{
"sheet_id": "S1.4",
"page": 12,
"dimensions": {"width": 2592, "height": 1728},
"annotations": {
"leaders": ["..."],
"section_tags": ["..."],
"detail_tags": ["..."],
"revision_triangles": ["..."],
"revision_clouds": ["..."]
},
"titleblock": {
"bounds": [2100, 50, 2550, 1700],
"viewport": [50, 50, 2100, 1700]
}
}
```
#### DELETE /v1/projects//sheets/
Remove a sheet from the graph and run maintenance rebuilds.
```json theme={null}
{
"deleted": true,
"sheet_id": "S1.4",
"cleanup": {
"deleted_nodes": 87,
"deleted_facts": 42,
"deleted_references": 12
},
"maintenance": {
"communities_rebuilt": 3,
"index_updated": true
}
}
```
***
### Search
#### POST /v1/projects//search
Hybrid retrieval combining Qdrant vector search, BM25 fulltext, and optional Neo4j graph context. **\$0.005/query**
| Field | Type | Required | Description |
| ----------------------- | ------- | -------- | -------------------------------------------- |
| `query` | string | Yes | Search query |
| `limit` | integer | No | Results per channel (1-100, default 10) |
| `channels` | array | No | Subset of `entities`, `facts`, `communities` |
| `include_graph_context` | boolean | No | Include graph neighborhood (default `true`) |
`/search` returns relevance-ranked results, not exhaustive traversal. For deterministic full traversal, use the `/entities` and `/relationships` endpoints instead.
```python Python theme={null}
results = project.search(
"W12x26 beam connections at grid A",
limit=10,
channels=["entities"],
include_graph_context=True
)
for entity in results.entities:
print(f"{entity.label}: {entity.score}")
```
```bash cURL theme={null}
curl -X POST https://api.stru.ai/v1/projects/proj_xxx/search \
-H "Authorization: Bearer $STRUAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"query": "W12x26 beam connections at grid A",
"limit": 10,
"channels": ["entities"],
"include_graph_context": true
}'
```
```json theme={null}
{
"entities": [
{
"id": "ent_abc123",
"type": "component_instance",
"label": "W12x26 Steel Beam",
"description": "Wide flange beam spanning grid A to C",
"sheet_id": "S1.4",
"bbox": [450, 320, 1200, 380],
"score": 0.94,
"attributes": {},
"graph_context": {
"connected_entities": [
{"id": "ent_def456", "type": "mention", "label": "Bolted Connection"},
{"id": "ent_ghi789", "type": "mention", "label": "Grid A"}
],
"relationships": [
{"type": "CONNECTS_TO", "fact": "W12x26 beam connects to column at grid A"}
]
}
}
],
"facts": [],
"communities": [],
"search_ms": 245
}
```
***
### Entities & Relationships
#### GET /v1/projects//entities
Deterministic entity listing for full traversal and export.
| Filter | Type | Description |
| ----------------- | ------- | ------------------------- |
| `sheet_id` | string | Filter by sheet |
| `type` | string | Entity type (see below) |
| `family` | string | Component family |
| `normalized_spec` | string | Normalized specification |
| `region_uuid` | string | Filter by region |
| `region_label` | string | Filter by region label |
| `note_number` | string | Filter by note number |
| `limit` | integer | Max results (default 200) |
**Supported types:** `mention`, `component_instance`, `component_type`, `region`, `community`
The `type` filter also accepts mention subtypes (e.g., `callout`) via `mention_type`. For bbox-based traversal, the primary types are `mention`, `component_instance`, and `region`.
```python Python theme={null}
# All entities for a sheet
entities = project.entities.list(sheet_id="S1.4", limit=1000)
# Filter by type
mentions = project.entities.list(
sheet_id="S1.4",
type="mention",
limit=1000
)
components = project.entities.list(
sheet_id="S1.4",
type="component_instance",
limit=1000
)
```
```bash cURL theme={null}
# All entities for a sheet
curl 'https://api.stru.ai/v1/projects/proj_xxx/entities?sheet_id=S1.4&limit=1000' \
-H "Authorization: Bearer $STRUAI_API_KEY"
# Mentions only
curl 'https://api.stru.ai/v1/projects/proj_xxx/entities?sheet_id=S1.4&type=mention&limit=1000' \
-H "Authorization: Bearer $STRUAI_API_KEY"
# Component instances only
curl 'https://api.stru.ai/v1/projects/proj_xxx/entities?sheet_id=S1.4&type=component_instance&limit=1000' \
-H "Authorization: Bearer $STRUAI_API_KEY"
```
```json theme={null}
{
"project_id": "proj_abc123",
"entities": [
{
"id": "ent_abc123",
"label": "W12x26 Steel Beam",
"type": "component_instance",
"description": "Wide flange beam spanning grid A to C",
"sheet_id": "S1.4",
"bbox": [450, 320, 1200, 380],
"attributes": {}
}
]
}
```
#### GET /v1/projects//entities/
Get entity detail with relationships and location info.
| Parameter | Type | Description |
| ----------------- | ------- | ------------------------------------------------------------ |
| `include_invalid` | boolean | Include invalidated relationships (default `false`) |
| `expand_target` | boolean | Expand `REFERENCES` target sheet summaries (default `false`) |
Returns entity record with `attributes`, `provenance`, `outgoing` relationships, `incoming` relationships, and `locations`.
#### GET /v1/projects//relationships
List facts and references as relationship rows.
| Filter | Type | Description |
| ----------------- | ------- | ------------------------------------- |
| `sheet_id` | string | Filter by sheet |
| `source_id` | string | Filter by source entity |
| `target_id` | string | Filter by target entity |
| `type` | string | Relationship type |
| `include_invalid` | boolean | Include invalidated (default `false`) |
| `invalid_only` | boolean | Only invalidated relationships |
| `orphan_only` | boolean | Only orphaned references |
| `limit` | integer | Max results (default 200) |
```json theme={null}
{
"project_id": "proj_abc123",
"relationships": [
{
"id": "rel_xxx",
"type": "CONNECTS_TO",
"fact": "W12x26 beam connects to column at grid A",
"source_id": "ent_abc123",
"target_id": "ent_def456",
"sheet_id": "S1.4",
"valid_at": "2026-02-08T19:41:45.800Z",
"invalid_at": null,
"target_sheet_id": null,
"target_unresolved": false
}
]
}
```
***
### Traverse Guide
Use this sequence for complete JSON traversal (not ranked results):
`GET /v1/projects`
`GET /v1/projects/{project_id}/sheets`
`GET /v1/projects/{project_id}/entities?sheet_id={sheet_id}&limit=...`
Filter by `mention`, `component_instance`, `region`, etc.
`GET /v1/projects/{project_id}/entities/{entity_id}`
`GET /v1/projects/{project_id}/relationships?...`
Use `/search` for relevance-ranked retrieval. Use `/entities` and `/relationships` for deterministic traversal and export.
***
## Reference
| Type | Description |
| -------------------- | ----------------------------------------------------------------- |
| `mention` | Detected annotation or text reference (subtypes: `callout`, etc.) |
| `component_instance` | Specific instance of a structural/MEP component |
| `component_type` | Component type definition (e.g., W12x26) |
| `region` | Spatial region on a sheet (view, zone) |
| `community` | Graph community grouping related entities |
| Type | Description |
| ----------------- | ---------------------- |
| `CONNECTS_TO` | Physical interface |
| `SUPPORTS` | Structural load path |
| `PART_OF` | Assembly hierarchy |
| `LOCATED_AT_GRID` | At grid intersection |
| `REFERENCES` | Points to sheet/detail |
| `DESCRIBES` | Annotates |
| `REVISES` | Marks revision |
| Plan | Detection | Graph Ingestion | Search |
| ---------- | ---------- | --------------- | ---------- |
| Free | 50/month | 10/month | 100/month |
| Pro | 1000/month | 500/month | 5000/month |
| Enterprise | Unlimited | Unlimited | Unlimited |
***
## Error Handling
The API returns errors in two formats:
**Validation / business errors:**
```json theme={null}
{"error": {"code": "invalid_page", "message": "Page 15 does not exist (total: 10)"}}
{"error": {"code": "rate_limited", "message": "Too many requests", "retry_after": 30}}
```
**FastAPI exceptions:**
```json theme={null}
{"detail": "Project not found"}
```
The SDK provides specific exception classes:
```python theme={null}
from struai import StruAI, AuthenticationError, RateLimitError, NotFoundError
try:
result = client.drawings.analyze("drawing.pdf", page=15)
except AuthenticationError:
print("Invalid API key")
except RateLimitError as e:
print(f"Rate limited. Retry after {e.retry_after} seconds")
except NotFoundError:
print("Drawing or page not found")
```
***
## Pricing
| Capability | Endpoint | Price |
| ------------------- | ------------------------------- | ------------- |
| **Raw Detection** | `POST /v1/drawings` | \$0.02/page |
| **Graph Ingestion** | `POST /v1/projects/{id}/sheets` | \$0.15/page |
| **Search** | `POST /v1/projects/{id}/search` | \$0.005/query |
| Need | Use | Cost Example |
| ---------------------------------------- | --------------- | ----------------- |
| Fast annotation detection, no storage | Raw Detection | 100 pages = \$2 |
| Searchable knowledge graph across sheets | Graph Ingestion | 100 pages = \$15 |
| Find specific entities or components | Search | 200 queries = \$1 |
**Full example:** A 96-page structural set with Graph Ingestion + 100 searches = **\$15.50**
# The Canvas
Source: https://docs.stru.ai/how-to/canvas
The workspace beside the chat where calc sheets, spreadsheets, and 3D models take shape as the agent builds them
## Overview
When an agent builds a document (a calculation sheet, a spreadsheet, a 3D model), it opens in the **Canvas**: a panel beside the chat where you watch it take shape while the agent works.
The Canvas appears automatically the first time a document is created in a conversation. A panel toggle in the header, next to the [design standard selector](/how-to/chat-input#overview), closes and reopens it. The [Structural Agent](/platform-guides/structural-agent) and the [BIM Agent](/platform-guides/bim-agent) use it.
Formatted, unit-aware calculation documents
Excel workbooks with live formulas
IFC building models and DXF drawings
## Calc sheets
Ask the Structural Agent for a design check and the calc sheet builds in the Canvas: title block, assumptions, code references, calculations, and the final pass/fail check.
* Page navigation at the top steps through multi-page documents. Recently changed lines flash briefly so you can follow the agent's edits.
* Click anywhere on the sheet to place a cursor. The agent sees where you're pointing, so "add a serviceability check here" needs no further explanation.
* The **⋯ menu** holds **Download PDF** plus display toggles for the calculation grid and page border:
The calc file itself (and a PDF report when you ask for one) arrives as download links in the chat and is saved to your [Files area](/how-to/file-management).
## Spreadsheets
Excel workbooks open as a live grid: sheet tabs along the bottom, zoom controls in the header, cells that recalculate.
* Zoom with the +/− controls, or hold Ctrl/Cmd and scroll.
* Click a cell to edit it and watch dependent formulas update. Useful for quick what-if checks while you read.
* The **⋯ menu** offers **Download PDF**. The workbook itself comes back as an `.xlsx` download link in the chat.
Want a change to stick? Tell the agent. Cell edits in the Canvas are for quick exploration. Ask the agent to make the change ("set the beam span to 32 ft and update the checks") and it becomes part of the real workbook.
## 2D & 3D models
When you work with the [BIM Agent](/platform-guides/bim-agent), or click an IFC/DXF file attached to a chat message, the model opens in a 3D viewer:
* Navigate like any CAD viewer: drag to orbit, scroll to zoom, use the axis gizmo in the corner to snap or reset the view. Toggle **Ortho / Persp** projection in the header.
* The **Layers panel** lists every layer with element counts. Click the eye to show or hide a layer.
* Click an element to select it and see its properties. In 2D drawings, drag left-to-right for a window selection and right-to-left for a crossing selection, like AutoCAD.
* Export from the download button in the header. DWG export carries a **Beta** tag while it rolls out.
## Switching between documents
A conversation can produce several documents. The dropdown on the document title lists everything the conversation has open (calc sheets, workbooks, and models together):
When the agent starts writing to a different document, the Canvas follows automatically.
## Good to know
Close the tab, come back tomorrow, reopen the conversation: the Canvas restores its documents automatically.
**Download PDF** saves a copy to your computer. The source documents (the calc file, the workbook) also land in the conversation's folder in [Files](/how-to/file-management), so nothing is lost if you never click download.
The Canvas splits the window with the chat. On a phone-width window the chat takes over and the Canvas stays out of the way.
The [Structural Agent](/platform-guides/structural-agent) (calc sheets, spreadsheets) and [BIM Agent](/platform-guides/bim-agent) (models). The [Review Agent](/platform-guides/review-agent) has its own drawing viewer, and the [ETABS & SAP2000 agents](/platform-guides/etabs-sap2000-agents) show the actual desktop application.
## Next steps
The agent that fills the Canvas with calc sheets and workbooks.
Inspect, edit, and quantify building models in the 3D viewer.
Where Canvas documents are saved for later.
Attach the files your documents are built from.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Using the Chat Input
Source: https://docs.stru.ai/how-to/chat-input
Type, attach files, dictate by voice, and pull in standards with @. Plus the keyboard shortcuts.
## Overview
The message box handles more than text. Attach files, dictate by voice, and reference your documents or design standards with @. This guide covers each, plus the shortcuts.
The pills above the chat set the context for every message: the [agent](/platform-guides/structural-agent) you're talking to (top-left dropdown) and the **design standard** next to it, which sets the code region your answers cite (US, Eurocode, Australia/NZ, Canada, Philippines, Singapore).
## Typing and sending
**Enter** sends. **Shift + Enter** adds a line break for prompts with a list of requirements. The send button (↑, bottom-right) becomes a stop button while the agent is responding.
You can type your next message while the agent is still working. Press Enter and it queues, then sends the moment the current response finishes.
## Adding files
Attach with the **+** button at the bottom-left of the message box, then **Upload from computer**. Drag-and-drop anywhere on the page and pasting images work too.
Up to 10 files per message: PDFs, images, Excel/CSV, Word, PowerPoint, and model files (IFC, RVT, DXF, DWG). Each attachment shows a preview card with upload progress.
Already uploaded it once? Type **@** and tag the file from your [Files](/how-to/file-management) instead of re-uploading. See [Mentions](/how-to/mentions).
### The Formatting standards toggle
The second row of the **+** menu controls whether the agent works from your [Standards folder](/how-to/standards-folder): the templates and boilerplate your company maintains. On by default, which is why deliverables come back in your format without you asking.
Two different things share the word "standards". The **Formatting standards** toggle points at your own Standards folder (your templates). The **@ picker's Standards section** is the built-in design code library (ACI, AISC, ASCE). See [Mentions](/how-to/mentions) for the second one.
### The project picker
On the [Review Agent](/platform-guides/review-agent) and [BIM Agent](/platform-guides/bim-agent), a **Select project** pill appears next to **+**. It sets which [project folder](/how-to/file-management) the agent reads from and saves into. Pick one before sending.
## Dictation
Click the **microphone** at the bottom-right and talk. A live waveform confirms it's recording, and your words appear in the input as you speak.
Click the stop button (the square that replaces the mic) to finish. The transcript lands in the message box to review and edit before sending; nothing sends automatically. Recordings run up to 5 minutes.
## Autocomplete
As you type, the input may offer a grey inline completion. **Tab** accepts it; keep typing to ignore it. After a task finishes, the empty input may suggest a likely next prompt, which Tab accepts too.
## Shortcuts
| Shortcut | What it does |
| ------------------- | ----------------------------------------------------------------- |
| **Enter** | Send |
| **Shift + Enter** | New line |
| **Tab** | Accept the grey autocomplete |
| **@** | Open the file and standards picker ([Mentions](/how-to/mentions)) |
| **/** | Focus the message box from anywhere |
| **Esc** | Close the picker; stop a response; press twice to clear the input |
| **↑** (empty input) | Recall your queued message for editing |
| **⌘K / Ctrl+K** | Search past conversations |
## Next steps
Tag files, folders, and design codes with @ instead of re-uploading.
What the Formatting standards toggle points at.
Put the input to work on real engineering tasks.
Where the documents you ask for take shape.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Drawing Review
Source: https://docs.stru.ai/how-to/drawing-review
Run an AI QA/QC review over a drawing set: catch code issues, coordination conflicts, and constructability problems before the set goes out
## Catch It Before It Goes Out
A **Drawing Review** is an AI QA/QC pass over a full drawing set: every sheet, cross-checked against the codes, the specs, and the other sheets.
Jobs engineers use it for:
* **QA/QC a set before issue**: a full pass over the drawings before they leave your desk
* **Code checking**: flag details, notes, and schedules with potential issues against the governing building codes, for your review
* **Catch coordination issues**: discrepancies between architectural, structural, and MEP sheets
* **Constructability**: find the underspecified and conflicting details that would otherwise come back as RFIs during construction
* **Cross-discipline conflict and rebar/detail checks**: conflicts and congestion called out across the sheets
* **Quantity takeoffs**: quantity schedules pulled from the set
You launch a review from the [Files area](/how-to/file-management), it runs on its own, and the results collect in the folder's **Reviews** section, with an email when it's done. Pricing is per drawing page, shown up front: see [Review Pricing](/how-to/review-pricing).
**Drawing Review vs. the Review Agent: two different things.** A *Drawing Review* is the formal, set-wide QA/QC run described on this page. The *[Review Agent](/platform-guides/review-agent)* is the chat agent you **talk to** about your drawings: ask questions, dig into specific findings. They work together: run the review, then interrogate the results in chat.
***
## Step-by-Step
A review covers the files in one folder, so give each drawing set (or submittal package) its own **project folder** in Files. Include the drawings plus anything the reviewer should read for context: specs, reports, calculations. New to folders? Start with [File Management](/how-to/file-management).
**Scope = the folder.** One drawing set per folder keeps reviews clean. Curate it before launching: the review reads what's there.
Right-click the folder's row in the **Projects** section of Files (on a trackpad: two-finger click, or Control-click) and choose **Enable Reviews**. The folder gets the review icon, a **Launch Review** button, and a **Reviews** section.
In a review folder, every file gets an automatic **Category** label (Drawing, Spec, Report, Code, Calculations) and **Language**, shown as editable dropdowns, so correct anything the detection got wrong. The **Include** checkbox controls whether a file is in scope.
**Only files categorized as Drawing are billed.** Specs, reports, and other supporting documents ride along free as reference material. See [Review Pricing](/how-to/review-pricing).
Click **Launch Review** in the folder's toolbar (you need **Editor** access, see [Sharing & Permissions](/how-to/file-access)). The review dialog opens with a suggested name and the list of files in scope, with page counts.
A **review mode** is the kind of check the reviewer runs. In one line each:
* **Code Compliance** (the default): flags potential building-code issues for your review
* **Consistency & Specs**: catches sheets, callouts, and specs that contradict each other
* **Constructability**: finds the unclear or missing details that turn into RFIs on site
* **Clash Detection**: flags cross-discipline conflicts visible across the sheets
* **Quantity Takeoff**: pulls quantity schedules from the drawings
* **Custom**: you define the scope yourself
Full detail on what each catches (and what it doesn't) in [Review Modes & Instructions](/how-to/review-modes).
Use **Additional Instructions** to brief the reviewer like you'd brief a junior engineer: the code edition, the areas you care about, what a useful finding looks like. Quantity Takeoff and Custom require instructions; for the others they're optional but powerful. Examples per mode in [Review Modes & Instructions](/how-to/review-modes#writing-additional-instructions).
The dialog shows the price before anything runs: pages in scope, page credits applied, and anything payable, with a **Price breakdown** you can expand. Click **Start review**; if your page credits don't cover the scope, the button offers to pay the difference by card and the review starts once payment confirms. Details in [Review Pricing](/how-to/review-pricing).
The review appears in the folder's **Reviews** section with a live status, and runs on its own. How long depends on the size of the set, so leave **Email me when the review completes** checked (it's on by default) and get on with your day. Results appear in the Reviews section when the run finishes, ready to open. Then bring your questions to the [Review Agent](/platform-guides/review-agent).
***
## Review Statuses
| Status | Meaning |
| -------------------- | ----------------------------------------------------------------- |
| **Awaiting payment** | The review is created and waiting on card payment to begin. |
| **Running** | The review is in progress. |
| **Completed** | Done. Open it from the Reviews section. |
| **Failed** | The review couldn't be completed. Contact support if it persists. |
| **Cancelled** | The review was cancelled and won't produce results. |
***
## What a Completed Review Delivers
Every completed review lands its results in a folder inside your project folder, named after the review. The core deliverables:
* **An Excel check register (.xlsx).** The full verification record: every check the review ran, passing and failing alike, with the sheets and sections compared, what was found, and a cross reference to each issue raised.
* **A PowerPoint deck (.pptx).** The visual walkthrough of the results, ready to circulate to the project team.
* **A PDF report** when the review calls for a written narrative.
* **The findings viewer.** When the review produced findings, they load automatically when you open the review: each issue pinned to its sheet with a highlight, ready for follow up with the [Review Agent](/platform-guides/review-agent).
Want a specific format? Ask for it in **Additional Instructions**: a Word summary, a second deck for the client, a workbook shaped to your QA template. Name the format and it lands in the results folder with everything else.
***
## Tips for Better Reviews
Reviews scope to the folder: mixing two projects in one folder means one combined review. Keep sets separate and reviews stay clean.
The review treats drawings and supporting documents differently. A spec mislabeled as a Drawing gets billed and reviewed as sheets; a drawing mislabeled as a Spec gets skipped. Ten seconds of label-checking pays off.
Superseded sheets or irrelevant files in the folder? Flip their **Include** checkbox off instead of deleting them.
Name the code edition, the discipline focus, and what you want back. See [Review Modes & Instructions](/how-to/review-modes) for worked examples.
**You're still the engineer of record.** The review surfaces findings. It doesn't make the call. Verify anything that matters before it drives a decision. The [Review Agent](/platform-guides/review-agent) is built for exactly that follow-up: ask it to investigate any finding against the drawings.
***
## Next Steps
What each mode catches, and how to write instructions
[Review Modes & Instructions](/how-to/review-modes)
Per-page pricing and page credits
[Review Pricing guide](/how-to/review-pricing)
Chat with your drawings and findings
[Review Agent guide](/platform-guides/review-agent)
Set up project folders for your jobs
[File Management guide](/how-to/file-management)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Sharing & Permissions
Source: https://docs.stru.ai/how-to/file-access
Give your engineers, reviewers, and project partners the right level of access to drawings and deliverables: roles, sharing, and access requests
## Give the Right People the Right Access
A project usually isn't a one-person job. The engineer running the review, the drafter fixing the sheets, the PM who just needs to read the findings: each needs a different level of access. In Stru, every file and folder has a **Manage Access** dialog that controls exactly that.
Common setups:
* **Project team**: share the job's [project folder](/how-to/file-management) with your engineers as **Editor** so they can upload sheets and [launch reviews](/how-to/drawing-review).
* **Review-only stakeholders**: add the PM or client as **Viewer**: they can open and download, but nothing changes under them.
* **Whole-company folders**: organization folders can default to everyone in your org, like the shared [Standards folder](/how-to/standards-folder).
Open Manage Access two ways:
* **For the folder you're in**: click **Manage access** in the toolbar at the top right.
* **For any file or folder**: right-click its row (on a trackpad: two-finger click, or Control-click) and choose **Manage access**.
**Everyone you share with needs a Stru account** (signing up is free). Every access level below applies to signed-in users; there are no anonymous, no-login links.
***
## The Three Roles
A **role** is what someone is allowed to do with a file or folder:
View, preview, and download. Can't upload, change, or run reviews.
Everything a Viewer can do, plus upload, create, rename, move, delete, and launch reviews.
Everything an Editor can do, plus manage who has access and transfer ownership.
**Editor applies to the whole folder's contents**: an Editor can rename, move, or delete anything in the folder, not just the items they added themselves. Give Editor to people doing the work; give Viewer to people reading it.
***
## Sharing with a Person
In the **Add people** field, type your teammate's name or email. Keep typing to add several people at once; each becomes a chip.
Choose **Viewer** or **Editor** for the people you're adding.
Your changes collect as a draft. Click **Save changes** to apply them all at once. (The button reads **Done** when there's nothing pending.)
Your teammate gets an in-app notification, and the item appears inside their own Files tree at its natural location; there's no separate "shared" area to dig through.
Yes: add their email as usual. They appear as an external invite and get access the moment they sign up with that email. Until then you can still change their role or revoke the invite.
Immediately after you save. Their very next action is denied, even in an already-open tab.
***
## General Access: the Default for Everyone Else
Below the people list, **General access** sets what happens for anyone who *isn't* listed individually:
| Level | Who can open it |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------ |
| **Restricted** | Only the people listed above. A hard boundary, even inside a shared project. |
| **Organization** | Everyone in your organization, at the default role you pick (Viewer or Editor). Available on organization folders. |
| **Anyone with the link** | Anyone signed in to Stru who has the link can view. |
On an organization folder, the Organization level pairs with a default role. Here is the shared Standards folder set to org-wide Editor:
Use **Copy link** to grab the item's link for a chat or email; the button confirms with **Link copied**.
**Need to lock down one subfolder inside a shared project?** Set that subfolder to **Restricted**: the rest of the project stays open to the team, but only the people you list can open that folder. And to exclude a single person from an org-wide folder, set their individual role to **Restricted** in the people list.
***
## Requesting Access
Opened a link you don't have access to? You'll see a **You need access** panel instead of the content:
Pick **Viewer** or **Editor**, and optionally add a note explaining why.
Click **Request access**. The owner is notified and you'll see **Request pending**.
Owners see incoming requests in **Notifications**, with **Approve as Viewer/Editor** and **Deny** buttons. Approval works like any normal share: the item appears in your Files.
***
## FAQs
Referencing a file in a conversation (see [Mentions & Attachments](/how-to/mentions)) requires **Editor** access or higher. If a file was shared with you as Viewer, ask the owner to raise your role.
Yes: on organization resources, an Owner can open the person's role menu and choose **Transfer ownership**. You keep Editor access after the transfer.
Organization owners and admins hold owner rights on every organization project, so access can always be fixed; an org project can't be orphaned.
Organization-owned folders and files are unaffected; the departed person just loses access. Their personal folders remain their own.
Changes apply when you click **Save changes**. Until then they're a local draft; closing the dialog without saving discards them.
***
## Next Steps
Set up project folders your way
[File Management guide](/how-to/file-management)
Editor access lets you launch reviews
[Drawing Review guide](/how-to/drawing-review)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# File Management
Source: https://docs.stru.ai/how-to/file-management
Set up your projects in Stru the way your company organizes work: project folders, drawings, deliverables, and where everything lives
## Set Up Your Work the Way Your Company Works
Everything you do in Stru (reviewing a drawing set, generating a calc package, producing an RFI) starts with files. The **Files area** is where they all live. A few minutes of setup here means every job has its own folder, your drawings are where reviews expect them, and every document the AI produces lands somewhere predictable.
Typical setups engineers use:
* **One project folder per job**: drawings, specs, and deliverables for each project together, ready for a [Drawing Review](/how-to/drawing-review).
* **A [Standards folder](/how-to/standards-folder) with your company templates**: so reports and RFIs come out formatted your way.
* **Shared organization folders**: so your whole team works from the same set. See [Sharing & Permissions](/how-to/file-access).
Open **Files** from the account menu in the top-right corner of the app, or go straight to [app.stru.ai/files](https://app.stru.ai/files).
Everything the AI generates for you, organized into one folder per conversation, automatically
Your personal project folders, where drawings and reviews live
Files you uploaded outside a project (mostly older uploads; new chat attachments go to conversation folders)
Your team's shared project folders and the shared Standards folder
**A "project" is just a folder.** The top-level folders under Projects and Organization are called projects, and the terms are interchangeable. When an agent in the chat asks you to *select a project*, it's asking which of these folders to read from and save into.
**There is no undo.** No trash, no version history: deleting a file or folder removes it for **everyone who has access**, permanently, and edits replace what was there. For stamped drawings and issued deliverables, keep an offline copy, and read [Deleting](#deleting-read-this-before-you-share) before you share broadly.
***
## Where Does My File End Up?
You never have to file anything by hand. Every file lands in a predictable place depending on how it entered:
| You do this | The file lands here |
| -------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
| Click **Upload** inside a folder (or drag files into it) | That folder |
| Drag files onto a card on the Files home screen | That area (Documents, Projects, Uploads, or Organization) |
| Attach a file in a chat | The conversation's own folder under **Documents** |
| Attach a file with a project selected ([Review](/platform-guides/review-agent) or [BIM](/platform-guides/bim-agent) agent) | The selected project folder |
| The AI generates a document for you | The conversation's own folder under **Documents** |
| The AI produces a deliverable inside a project | The selected project folder |
| You tell the agent *"save this as a standard"* | Your [Standards folder](/how-to/standards-folder) |
**Why one folder per conversation?** Under **Documents**, every conversation gets its own folder, named after it, so nothing the AI makes for you is ever lost, even for quick one-off questions. Work that belongs to a job goes to that job's project folder whenever a project is selected, so your project folders stay organized by job, the way you'd file it yourself.
***
## Getting Files In
There are two front doors: the Files area and the chat.
Open the folder you want the files in and click **Upload** in the toolbar at the top right (next to **+ New Folder**), or simply drag files from your computer into the folder. From the Files home screen, you can drag files straight onto the four area cards.
Click the **+** button in the message box and choose **Upload from computer**, or drag the file anywhere onto the page. The file is stored automatically (see the table above). Full details in [Using the Chat Input](/how-to/chat-input).
If the file is already in your Files, type **@** in the message box and pick it. The agent gets the existing file. See [Mentions & Attachments](/how-to/mentions).
***
## Setting Up a Project Folder
Say you just got drawings for a new job. Here's the setup:
In **Projects**, click **+ New Folder**, name it after the job (e.g. *"Escambia Substation"*), and press Enter.
Open the folder and drag in the drawings, specs, and anything else that belongs to the job.
Right-click the folder's row **in the Projects list** (on a trackpad: two-finger click, or Control-click) for the folder actions: enable reviews for a drawing set (see [Drawing Review](/how-to/drawing-review)), or share it with the team (see [Sharing & Permissions](/how-to/file-access)).
**Folder actions live on the folder's row, not inside it.** To rename a folder, enable reviews, set it as your Standards folder, or delete it, right-click its row **in the parent listing**. Inside an open folder, the toolbar only offers content actions (New Folder, Upload, Manage access, Launch Review).
Check the box next to one or more items, then **drag the selection onto a folder** in the list. That's the move. A hint appears in the toolbar when a move is possible.
Yes: create a folder inside another folder. The breadcrumb trail at the top jumps back to any parent level. A nested folder does not inherit its parent's type: every new folder starts plain.
Check the box next to each file or folder. The toolbar shows bulk actions: **Delete (n)**, and **Open in Split View** when exactly two PDFs are selected.
***
## Folder Types
Every folder is one of three types, each with its own icon in the file list:
Pure storage, no review tools. Every new folder starts as this.
Carries the drawing-review workflow: a **Launch Review** button, a **Reviews** section, and automatic file labeling. See [Drawing Review](/how-to/drawing-review).
Your company's reference library: templates and formats the AI follows. See [Your Standards Folder](/how-to/standards-folder).
Change a folder's type any time by right-clicking its row: **Enable Reviews** / **Disable Reviews** switches between plain and review; **Set as Standards Folder** designates your standards library.
**A folder is exactly one type at a time.** A Standards folder can't have reviews enabled, and a review folder can't be designated as Standards; switch it back to plain first. A folder with reviews in its history keeps its Reviews section until those reviews are deleted.
### File labels in review folders
In a review folder, every file you upload is automatically labeled with a **Category** (Drawing, Spec, Report, Code, Calculations) and **Language**, shown as editable dropdowns, so you can correct anything the detection got wrong. The **Include** checkbox controls whether the file is part of the review scope. Plain folders don't show these columns.
***
## Opening and Previewing Files
* **PDF, Word (.docx), PowerPoint (.pptx)**: the paged document viewer. Drawing sheets are typically PDFs, so they open here.
* **Images**: a lightbox with download, fullscreen, and next/previous.
* **Excel (.xlsx)**: an in-app spreadsheet preview with sheet tabs.
* **Markdown, plain text, CSV**: in-app text previews.
* **CAD and BIM models (.ifc, .dxf)**: open in the 3D/2D viewer from a chat conversation; see [The Canvas](/how-to/canvas).
Select exactly two PDFs (check their boxes) and click **Open in Split View** in the toolbar. Both sheets open side by side. Useful for revision comparisons.
The document viewer opens with a chat panel beside it. The chat knows which document you have open and can answer questions about it. The dropdown at the top of the viewer switches between documents in the same folder.
Right-click a file for **Manage Access**, **Rename**, **Download**, and **Delete**.
***
## Deleting: Read This Before You Share
Deleting a file or folder removes it **for everyone who has access**, not just for you. A confirmation dialog stands in the way of an accidental one-click delete, but once confirmed the item is gone. There is no trash to recover it from, and no version history to roll back to.
**Editors can delete, and Editor is the default role on organization folders.** If a folder holds files you can't afford to lose (stamped drawings, issued deliverables), tighten access to specific people via [Manage Access](/how-to/file-access) or keep an offline copy.
***
## Troubleshooting
Shared items appear inside your own Files tree at their natural location. Check your notification for a direct link, then browse to it under **Projects** (or **Organization** for org-wide projects). More in [Sharing & Permissions](/how-to/file-access).
Your role on it is **Viewer**: view, preview, and download only. Ask one of the folder's Owners to raise you to Editor. Roles are explained in [Sharing & Permissions](/how-to/file-access).
The chat's project menu hides folders where you can't upload, because the agent saves its output into the selected project. Ask a project Owner to raise your role to Editor.
Open or refresh the folder's file list; detection catches it up automatically.
***
## Quick Reference
| Term | What it means |
| ----------------------------------- | ------------------------------------------------------------------------------------ |
| **Project** | A top-level folder under Projects or Organization; the folder an agent works inside. |
| **Plain folder** | Storage only. Default for every new folder. |
| **Review folder** | Has Launch Review, a Reviews section, and automatic file labels. |
| **Standards folder** | Your company's reference library, marked with a book icon. |
| **Include / Language / Category** | Review-folder file labels that control and describe review scope. |
| **Documents (conversation folder)** | Auto-created folder holding everything from one conversation, named after it. |
| **Move** | Select items, then drag the selection onto a destination folder. |
***
## Next Steps
Give your team the right level of access
[Sharing & Permissions guide](/how-to/file-access)
Run an AI review over a drawing set
[Drawing Review guide](/how-to/drawing-review)
Deliverables in your company's format
[Standards Folder guide](/how-to/standards-folder)
Attach and reference files in conversations
[Chat Input guide](/how-to/chat-input)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Generate RFIs & RFAs from Drawings
Source: https://docs.stru.ai/how-to/generate-rfi-rfa
Point the Structural Agent at a drawing sheet and get a ready-to-review RFI or RFA as a PDF
## Overview
The [Structural Agent](/platform-guides/structural-agent) reads a drawing sheet and drafts a **Request for Information (RFI)** or a **Request for Approval (RFA)** for you: a formatted PDF that references the relevant details on the sheet. You point it at the drawing, state the question or the proposed change, and the agent handles the reading, the writing, and the formatting.
Both directions of the workflow are covered: a contractor or detailer raising an RFI to the design team, and an engineer of record drafting a response or raising a query to the architect or owner.
**What this does and doesn't do.** Stru drafts the document. RFI numbering, transmittal, and your RFI log stay in your project's own process: review the PDF, assign it a number from your log, and send it through your usual channel. An RFA proposes an engineering change, so the substitution still requires design verification before anyone builds it.
## Step-by-step
Open [app.stru.ai](https://app.stru.ai) and pick **Structural Agent** from the agent dropdown in the top-left corner (new to it? see the [Structural Agent guide](/platform-guides/structural-agent)).
Two ways to get the drawing in front of the agent:
* **Upload it**: click the **+** button in the message box and choose **Upload from computer**, or drag the PDF onto the page.
* **Tag an existing file**: if the drawing is already in your Files, type **@** in the message box and pick it. The picker browses your Standards and Files, and the arrow keys navigate into project folders (full walkthrough: [Mentions & Attachments](/how-to/mentions)).
Name the sheet, the detail, and the specific question or proposed change:
```text Example: RFA (propose a substitution) theme={null}
@1PGDEMO.pdf Generate an RFA to the design team proposing a
bolted connection in place of the welded connection on detail 2,
to simplify field erection. Note that connection design
verification will follow.
```
```text Example: RFI (contractor to the EOR) theme={null}
@1PGDEMO.pdf The base plate thickness on detail 5 conflicts
with the schedule on S-501. Generate an RFI to the EOR asking
which governs.
```
Send the message. The agent reads the drawing, pulls the relevant details, and drafts the document. Expect **5 to 10 minutes** for a typical sheet.
The finished RFI or RFA comes back in the conversation as a **PDF**, and is saved to the conversation's folder under **Documents** in your [Files area](/how-to/file-management). Review it, assign it a number from your project's RFI log, and send it.
## Using your company's RFI/RFA template
If your company has a standard RFI or RFA format, the agent follows it instead of its default layout:
Click the **+** button in the message box and choose **Upload from computer** to add your template.
Reference the template with **@** alongside the drawing:
```text theme={null}
@1PGDEMO.pdf @Company_RFI_Template.pdf Generate an RFI about
the beam-to-column connection on detail 3, following the
attached template format.
```
Using the same template every time? Put it in your [Standards folder](/how-to/standards-folder) instead. With **Formatting standards** on in the **+** menu (the default), the agent consults your standards automatically. No need to tag the template in every prompt.
## Tips for better results
Point the agent at the exact location: *"detail 2 on the attached sheet"* beats *"the connection."* If the set has multiple sheets, name the sheet number too.
Give the agent both the substitution and the justification: *"bolted connection instead of welded, to simplify field erection."* The agent builds the case around it.
Say what's unclear or conflicting and what answer you need: *"confirm which governs"*, *"clarify the intended weld size"*, *"provide the missing dimension."*
The agent drafts the document; the engineering responsibility for what goes out is yours. Check the references, the technical claims, and the project details before it leaves your desk.
## Next steps
Where your drawings and generated PDFs live.
Make every RFI come out on your company form.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Mentions & Attachments (@)
Source: https://docs.stru.ai/how-to/mentions
Tag design codes, files, and whole folders in your message with @. No re-uploading, no copy-pasting.
## Overview
Type **@** in the message box and a picker opens with everything the agent can work from: the built-in **design standards library** (building codes) and **your files** (everything in your [Files area](/how-to/file-management)). Tagging beats re-uploading: the agent gets the exact document and your message stays readable.
The picker has two sections, and they're different things:
Built-in design codes (ACI, AISC, ASCE, and your region's codes), shown in green. Filtered by your [design standard selector](/how-to/chat-input#overview): with US selected, you see the US codes.
Your own drawings, specs, spreadsheets, and folders from the Files area, shown in purple. Browse into folders like a file manager.
Not to be confused with your Standards *folder*. The green **Standards** section is the built-in library of published design codes. Your own [Standards folder](/how-to/standards-folder) (company templates and formatting references) lives in the Files section, and the **Formatting standards** toggle in the [+ menu](/how-to/chat-input#the-formatting-standards-toggle) points the agent at it automatically.
## Using the picker
The picker opens on the **Standards** section, showing design codes matched to your selected design standard:
* **↑ / ↓** move the selection.
* **→** switches from Standards to **Files**, and drills *into* a selected folder.
* **←** backs out again.
Keep typing after the **@** and the picker searches the current section, including inside subfolders, with the folder path shown next to each match.
The selection becomes a colored chip in your message: green for standards, purple for files and folders. Add as many as you need, and press **Backspace** on a chip to remove the whole thing in one keystroke.
## Tagging a whole folder
Select a folder and press **Enter** instead of drilling into it. The agent gets the folder's contents. Use this when the task spans a document set:
```text Example theme={null}
@Skyline_Tower_Drawings Compare the column schedule against the
foundation plan and list any mismatched sizes.
```
## When to @, when to attach
| Situation | Do this |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------ |
| The file is already in your Files area | **@** it. No re-upload, no duplicate copies. |
| The file is on your computer, not uploaded yet | Attach it: **+** button, drag and drop, or paste ([how](/how-to/chat-input#adding-files)). |
| You need a design code clause | **@** it from the Standards section, or name the code in your prompt. |
| The whole project folder matters | **@** the folder itself. |
Attachments become @-able. Anything you attach is saved into your Files automatically, so next conversation you tag it instead of hunting for the file again. See [File Management](/how-to/file-management) for where attachments land.
## Next steps
The rest of the message box: uploads, dictation, shortcuts.
How your Files area is organized and where attachments go.
Company templates the agent follows automatically.
A real workflow built on @-tagging drawings.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Review Modes & Instructions
Source: https://docs.stru.ai/how-to/review-modes
Pick the review that matches the job: what each of the six Drawing Review modes catches, and how to brief the reviewer for findings you can act on
## Pick the Review That Matches the Job
When you [launch a Drawing Review](/how-to/drawing-review), you choose a **review mode**, the kind of check the reviewer runs on your set, and optionally refine it with **additional instructions**. Different points in a project call for different reviews: a code check before issue is not the same job as a constructability pass before bid.
***
## The Six Modes, by the Job They Do
**The pre-issue check.** Flags details, notes, and schedules with potential issues against the governing building codes, across disciplines. It surfaces the flags; the compliance call stays with you, the engineer. The default, and the right first pass on most sets.
**The after-revisions check.** Cross-references sheets, details, sections, and callouts against each other and the specifications, catching conflicts, mismatched tags, and references that point nowhere. Run it after a heavy revision cycle.
**Catch the things that become RFIs later.** Reads the set the way the field will, flagging missing dimensions, underspecified details, and conflicting information that would otherwise come back as RFIs during construction. Run it before the set goes out to bid.
**The coordination check on the sheets.** Flags cross-discipline conflicts visible across the drawing set: structure vs. MEP layouts, embeds vs. rebar congestion, equipment vs. stated clearances. It reads the drawings, not a 3D model. For model-based geometric clash detection, use the [BIM Agent](/platform-guides/bim-agent) with your IFC model.
**The estimating job.** Produces quantity schedules from the drawings. Tell it what to quantify and in what units. This mode requires instructions.
**Your scope, your rules.** You define what to check, what to ignore, and what the output should look like. Requires instructions.
**Modes seed the instructions.** Picking a mode pre-fills the review's instructions with that mode's scope. The **What this does** text under the cards tells you exactly what you're getting. You can run it as-is, or edit the instructions to narrow or extend it.
***
## Writing Additional Instructions
The **Additional Instructions** field is how you brief the reviewer. It's optional for most modes and **required** for Quantity Takeoff and Custom. The badge next to the field tells you which.
Brief it like you'd brief a junior engineer doing the review for you:
* **The governing code and edition**: *"Check against IBC 2024 and ACI 318-19"* beats letting the reviewer infer it.
* **Where to focus**: discipline, sheet range, or system: *"structural sheets only,"* *"focus on the podium transfer level."*
* **What a useful finding looks like**: *"flag anything that would require an RFI,"* *"list every detail referencing a spec section that doesn't exist."*
* **The output you want** (Takeoff/Custom): *"a quantity schedule of all structural steel by member size, in tons."*
### Example briefs, mode by mode
```text theme={null}
Check the structural sheets against ACI 318-19 and AISC 360-22.
Prioritize seismic detailing. This is SDC D. Flag any detail
where reinforcement development or splice lengths look short.
```
```text theme={null}
Cross-check every detail callout against the sheets it references.
Compare the foundation schedule on S-201 with the plan callouts,
and flag any spec section references that don't exist in the spec.
```
```text theme={null}
Review from the GC's perspective. Flag missing dimensions,
congested connections, conflicting details, and anything a
steel detailer would need to RFI before shop drawings.
```
```text theme={null}
Produce a takeoff of all cast-in-place concrete by element type
(footings, walls, columns, slabs) in cubic yards, and rebar
tonnage per level based on the schedules.
```
**Vague scope in, vague findings out.** The single biggest upgrade to review quality is naming the code edition and saying what you want flagged.
***
## FAQs
**Code Compliance** for a design review before issue; **Constructability** before the set goes to bid; **Consistency & Specs** after a heavy revision cycle.
Pick the closest mode and extend it in the instructions, e.g. Code Compliance plus *"also flag any callout inconsistencies you notice along the way."* For a fully mixed scope, use **Custom** and describe everything.
No. Pricing is per drawing page in scope, regardless of mode or instructions. See [Review Pricing](/how-to/review-pricing).
Everything in the folder with its **Include** checkbox on: drawings are reviewed page by page, and supporting documents (specs, reports, calcs) are reference context. Labels and scope are covered in the [Drawing Review guide](/how-to/drawing-review#step-by-step).
***
## Next Steps
The full launch-to-results walkthrough
[Drawing Review guide](/how-to/drawing-review)
Per-page pricing and page credits
[Review Pricing guide](/how-to/review-pricing)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Review Pricing & Page Credits
Source: https://docs.stru.ai/how-to/review-pricing
Know exactly what a Drawing Review costs before you start: per-page pricing, page credits, and organization pools
## Know the Cost Before You Commit
[Drawing Reviews](/how-to/drawing-review) are priced by one simple rule: **you pay per drawing page in scope**. Supporting documents (specs, reports, calculations, images) ride along free as reference material. You always see the full price before a review starts, and nothing runs until you confirm it.
Each drawing page in the review's scope
A review page credit covers one drawing page
Specs and supporting documents aren't billed
**Separate from your plan credits.** Drawing Review is billed with its own **review page credits**. It never draws from the monthly usage credits that power your conversations. Check balances any time in your Usage and Credits pages.
***
## The Quote: What You See Before Starting
The review dialog shows exactly what the run costs before you start it:
* **Pages in scope**: the page count across the files labeled **Drawing** with their **Include** checkbox on (see [the Drawing Review guide](/how-to/drawing-review#step-by-step)).
* **Credits applied**: page credits from your balance are used first, automatically.
* **Amount due**: if credits don't cover the full scope, the remainder is payable by card: the start button becomes **Pay**, and the review begins once payment confirms.
Expand **Price breakdown** to see per-drawing page counts and how credits were applied.
**Only drawings are billed.** Check the **Category** labels before launching: a spec mislabeled as a Drawing adds pages to the bill. Fixing a label takes two clicks.
***
## Review Page Credits
Page credits are the prepaid currency for reviews:
* **1 credit covers 1 drawing page**, whatever the [review mode](/how-to/review-modes).
* **They never expire.**
* They're applied automatically to every quote before any card payment is requested.
***
## For Organizations
Organizations share a **review page credit pool**, managed by admins from **Organization → Credits**:
* **Buy page credits**: top up the pool at any time.
* **Per-member allocation**: control how much of the shared pool each member can draw. A member who exceeds their allocation can still run reviews by paying by card.
* Reviews launched by members draw from the pool first, then their own balance.
Organization admins see the pool and per-member usage under **Organization → Credits**. For everyone, the review dialog's quote shows exactly how many credits will be applied to the run you're about to start.
No. Pricing is pages × rate regardless of the mode or instructions. See [Review Modes](/how-to/review-modes).
Scope it: flip the **Include** checkbox off for superseded sheets, and split a massive set into per-package folders so each review covers only what you need checked.
Email **[support@stru.ai](mailto:support@stru.ai)** with the review name and the folder it was launched from, and the team will make it right.
***
## Next Steps
Launch your first review
[Drawing Review guide](/how-to/drawing-review)
Pick the review that matches the job
[Review Modes & Instructions](/how-to/review-modes)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Your Standards Folder
Source: https://docs.stru.ai/how-to/standards-folder
Put your company's templates and formatting guides in one folder, and every deliverable the AI produces comes out your way
## Deliverables in Your Company's Format
Every firm has its own way documents should look: the report cover sheet, the RFI form, the calc-package layout, the title block conventions. The **Standards folder** is how you teach that to Stru once: drop your templates and formatting guides in, and the AI consults them automatically whenever it produces a document for you.
What engineers put in it:
* **RFI / RFA templates**: so a generated RFI follows your form (see [Generate RFIs & RFAs](/how-to/generate-rfi-rfa))
* **Report boilerplate and cover sheets**: calc packages come out looking issued, not generic
* **Formatting guides and checklists**: units conventions, numbering, QA sign-off blocks
* **Representative calculation examples**: "make it look like this one"
The Standards folder is marked with a **book icon** in your file list:
**Your Standards folder vs. design standards.** The Standards *folder* holds **your own** reference documents. The **Standards** section you see when you type **@** in the chat is different: that is the built-in design-code library (ACI, ASCE, AISC, and regional codes) provided by Stru. This guide is about your folder; the code library is covered in [Mentions & Attachments](/how-to/mentions).
***
## Where It Comes From
* **Organizations**: every organization gets a shared **Standards** folder under the Organization area automatically. The whole team (and the AI) works from one library. By default every member can edit it; see [Sharing & Permissions](/how-to/file-access) to tighten that.
* **Your own designation**: you can point your conversations at any folder you can edit instead: right-click the folder's row in [Files](/how-to/file-management) (on a trackpad: two-finger click, or Control-click) and choose **Set as Standards Folder**. It gets the book icon, and your choice wins over the organization default. Right-click again to remove the designation and fall back to the org folder.
The *pointer* is personal: designating a folder only changes which folder **your** conversations use. The *contents* of a shared folder are shared as usual: if you all point at the org Standards folder, you're all working from the same documents.
No: a folder is exactly one type at a time (see [Folder Types](/how-to/file-management#folder-types)). Disable reviews on a folder before setting it as your Standards folder.
***
## How the AI Uses It
Click the **+** button in the message box. **Formatting standards** has an on/off toggle (it is **on by default**) and links straight to the folder in Files.
Chat normally: ask the [Structural Agent](/platform-guides/structural-agent) for a report, an [RFI](/how-to/generate-rfi-rfa), a calc sheet. With the toggle on, the agent has your Standards folder as working reference and follows the formats it finds there.
When the agent produces something worth reusing, tell it *"save this as a standard"* and the document lands in your Standards folder for next time.
**Using the same template every time?** Put it in the Standards folder once instead of tagging it in every prompt. For a worked example with an RFI template, see [Generate RFIs & RFAs](/how-to/generate-rfi-rfa#using-your-companys-rfirfa-template).
***
## Keeping It Healthy
**Updates are live edits.** Any Editor can change a template in place, and the whole team (and the AI) sees the new version immediately. There is no version history, and deletions are permanent (see the no-undo rules in [File Management](/how-to/file-management#deleting-read-this-before-you-share)). Keep an offline copy of anything critical, and tighten who can edit via [Sharing & Permissions](/how-to/file-access).
Short and current beats large and stale. A handful of well-chosen templates (report format, RFI form, calc example) outperforms a dump of every document your firm has ever produced. The AI follows what it finds.
Nothing breaks. Organization members fall back to the org Standards folder; individual accounts fall back to none. Your designation resumes automatically if access comes back.
No: deliverables go to your conversation folder or selected project as usual (see [Where Does My File End Up?](/how-to/file-management#where-does-my-file-end-up)). The Standards folder only changes when you explicitly save a standard.
***
## Next Steps
Use a company template from your Standards folder
[RFI & RFA guide](/how-to/generate-rfi-rfa)
Folder types and organization
[File Management guide](/how-to/file-management)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Stru AI Documentation
Source: https://docs.stru.ai/index
An ecosystem of AI agents for architectural, civil, and engineering work: calc packages, drawing reviews, RFIs, quantity takeoffs, and ETABS/SAP2000 models through chat
Stru AI is an ecosystem of AI agents for architectural, civil, and engineering work. An agent is an AI assistant you chat with that does the work itself: it reads your drawings and specs, runs calculations against building codes, produces documents in your format, and drives ETABS and SAP2000. You describe the task. The agent delivers the result and you verify it.
## Do your work
QA/QC a set before it goes out: code issues, coordination conflicts, missing details.
Turn a drawing sheet and a question into a ready-to-review PDF.
Quantities and schedules from a drawing set or a BIM model.
Deliverables that follow your company templates and title blocks.
## The agents
Pick an agent from the dropdown in the top-left of the chat. Each is built for a different kind of work.
The agent you start on. Calc packages, code checks with cited clauses, spreadsheets, site hazard data.
Chat with a drawing set: trace callouts, compare revisions, verify review findings.
Build and analyze models in the ETABS and SAP2000 installed on your machine.
Inspect, edit, take off, and cost IFC and Revit models.
## Set up your workspace
Project folders, where files land, and how reviews expect them organized.
Load your templates once; deliverables come out in your format.
Give your team and consultants the right level of access.
Required for the ETABS and SAP2000 agents. Install and pair it once.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# BIM Agent
Source: https://docs.stru.ai/platform-guides/bim-agent
Inspect, tag, cost, and clean up IFC and Revit building models using natural language prompts
## Getting Started
The BIM Agent lets you work with building information models (IFC and Revit files) through conversation. Upload a model, describe what you need, and the agent reads, analyzes, or edits it for you.
Open [app.stru.ai](https://app.stru.ai) and sign in with your email.
Use the dropdown in the **top-left** corner to choose **BIM Agent**.
Attach an `.ifc` or `.rvt` file using the **+** button next to the message box. The file appears as a card above your prompt.
Write your request in plain language. No file format or query syntax needed:
```text theme={null}
Review the BIM/IFC model and summarize element counts, material
quantities, major assemblies, and any obvious modeling gaps.
```
The agent works through the model, shows its reasoning, and renders the 3D geometry alongside its findings. Use **Ortho/Persp** to switch views and the **Layers** panel to isolate categories.
**Pro Tip:** Use **@** to search building codes and standards while writing prompts, just like the ETABS/SAP2000 agents.
***
## IFC vs. Revit: What's Supported
The agent's depth of access depends on the file format you upload.
**Full support**: the agent can read and edit everything:
* Element lists, properties, and spatial hierarchy
* Quantity takeoff and cost estimation
* Data-quality warnings
* Tagging, renaming, and deleting elements
* Batch edits across many elements at once
**File-level facts only**, without a live Revit connection:
* Project/file metadata
* Linked-file references
* Data-quality warnings at the file level
Element-by-element data (counts, properties, geometry edits) requires a live connection to a running Revit session. The agent will tell you clearly when that's needed rather than guessing.
**Working with a Revit model?** The agent can convert it to IFC first (where a converter is configured) for full element-level analysis, editing, and costing. Ask: *"Convert this Revit file to IFC so we can dig into the elements."*
***
## What the BIM Agent Can Do
Summarize a model's spatial tree, element counts, properties, and material breakdown. Spot missing data, unclassified elements, and modeling gaps.
Run per-element quantity takeoffs (areas, volumes, lengths) and roll them up into a priced bill of quantities, broken down by storey or element type.
Set or fix properties (fire ratings, classifications, names) on one element or hundreds at once, as a single all-or-nothing batch.
Surface deterministic warnings (missing properties, unclassified elements, orphaned geometry) before they become downstream problems.
Compare two versions of a model to see what changed: element counts, quantities, or newly introduced warnings.
Ask open-ended questions the standard summaries don't cover. The agent writes and runs the analysis behind the scenes and reports back the answer, not the code.
**Nothing is ever silently changed or fabricated.** The agent asks before saving changes, tells you exactly what it modified, and reports missing data as "unavailable" rather than guessing a number.
***
## Writing Effective Prompts
### The Golden Rule
**Either be specific OR explicitly give the agent discretion.** Avoid vague prompts.
```text ✅ Good: Be Specific theme={null}
Set the FireRating property to "2HR" on every beam under
Pset_BeamCommon. Show me the list of beams you'll update
before saving.
```
```text ✅ Good: Give Discretion theme={null}
Review this model for data quality issues and use your
judgment on what's worth flagging. Focus on anything that
would block a quantity takeoff.
```
```text ❌ Bad: Vague theme={null}
Fix the model.
```
### Key Prompt Elements
If you're uploading a Revit file but only need file-level facts, say so. It avoids the agent reaching for element-level data it can't get offline:
✅ "This is a Revit file. Just pull the project metadata and linked files for now."
For large tagging or costing jobs, work incrementally:
```text theme={null}
First, list all beams missing a fire rating.
[Review the list]
Now tag all of them with FireRating = 2HR.
[Confirm]
Finally, run a cost estimate on the updated model.
```
For edits you want to double-check first:
✅ "Show me what would change, but don't save yet."
✅ "Once I confirm, save this as a new file rather than overwriting the original."
***
## Common Use Cases
### Model Summary
```text theme={null}
Review this IFC model and summarize element counts, material
quantities, major assemblies, and any obvious modeling gaps.
```
### Spatial Breakdown
```text theme={null}
Show me the building's spatial hierarchy (sites, buildings,
storeys, and spaces) and how many elements live in each storey.
```
### Finding Specific Elements
```text theme={null}
List every beam on Level 2, along with their sections and
lengths.
```
### Data Quality Sweep
```text theme={null}
Check this model for data quality issues: missing properties,
unclassified elements, or anything that would block a cost
estimate.
```
### Single Element Fix
```text theme={null}
Set the fire rating on beam ID 151 to 2HR under
Pset_BeamCommon, and rename it to "Exterior Beam A".
```
### Batch Tagging
```text theme={null}
Find every beam missing a fire rating and set it to 2HR.
Show me the full list of affected beams before you save.
```
### Cleaning Up Orphaned Elements
```text theme={null}
Find any elements that look duplicated or disconnected from
the spatial hierarchy, and remove them. Don't touch anything
that still contains other elements. Flag those instead.
```
### Renaming for Consistency
```text theme={null}
Rename all columns to follow the pattern "Column--"
based on their location, and show me the before/after mapping.
```
### Quantity Takeoff
```text theme={null}
Run a quantity takeoff on all beams and columns. I need areas,
volumes, and lengths per element.
```
### Full Cost Estimate
```text theme={null}
Generate a priced bill of quantities for this model using
MasterFormat classification, broken down by storey and
element type. Flag anything without a rate.
```
### Classification Check
```text theme={null}
Classify every element in this model under Uniclass and tell
me which ones don't have a clear classification.
```
***
## Advanced Usage
### Batch Operations
Describe the whole batch in one prompt. The agent treats it as one all-or-nothing change, so a problem with one element doesn't leave the model half-edited:
```text theme={null}
Tag beams 151, 162, and 178 with FireRating = 2HR under
Pset_BeamCommon, and rename beam 151 to "Exterior Beam A".
Apply all of these together, and if any one of them fails,
don't save any of the changes.
```
### Study and Compare Models
```text theme={null}
Compare 'Design_A.ifc' and 'Design_B.ifc':
1. Element count differences by type
2. Material quantity differences
3. Any new data-quality warnings introduced in Design_B
```
**Use cases:** Track changes between design revisions, verify a consultant's model matches expectations, or audit what changed after a coordination pass.
### Convert Between Formats
```text theme={null}
Convert 'Building_Model.rvt' to IFC so we can run a full
quantity takeoff and check for data quality issues.
```
### Ad-Hoc Questions
When a standard summary doesn't answer your question, ask anyway. The agent figures out how to get the answer:
```text theme={null}
How many exterior wall types are in this model, and what's
the total exterior wall area?
```
```text theme={null}
Are there any spaces without a defined area? List them by name.
```
***
## Best Practices
**Start broad, then narrow**
Ask for a full summary first, then drill into specific categories or storeys once you know what's there.
**Ask about gaps, not just what exists**
*"What's missing or unclassified in this model?"* often surfaces more useful information than a plain element count.
**Preview before you commit**
*"Show me what would change, but don't save yet"* lets you catch mistakes before they're written.
**Save to a new file when in doubt**
✅ *"Save this as 'Tagged\_Model.ifc' rather than overwriting the original"*
**Be explicit about scope**
✅ *"Tag only the beams on Level 2, not the whole building"*
❌ *"Tag some beams"*
**Run a takeoff before pricing**
Ask for quantities first so you can sanity-check them before the agent rolls them into a priced estimate.
**Specify the classification system**
✅ *"Use MasterFormat"* or *"Use Uniclass"*. The agent will otherwise pick a sensible default, but naming it avoids surprises.
**Ask what's missing, not just the total**
✅ *"What elements don't have a rate, and how much of the total do they represent?"*
***
## Troubleshooting
This is expected for Revit files opened offline: element lists, properties, and geometry edits need a live Revit connection. The agent will tell you this rather than guessing. Ask for file-level metadata instead, or request a conversion to IFC for full access.
The agent won't delete a spatial container (like a storey or space) that still holds other elements, since that would silently orphan its contents. Ask it to first move or delete the contained elements, or confirm you want the whole branch removed.
The agent never overwrites a file silently. Give it a new file name, or explicitly confirm you want to update the existing model in place.
Batch edits are all-or-nothing: if one item in the batch fails, none of the changes are saved. Ask the agent what failed and why, fix that item, and re-run the batch.
The agent never fabricates a quantity or rate. If something is missing, it shows up as "unavailable" or as an exception in the estimate, not a silent zero. Ask *"What's missing from this estimate?"* to see the gaps directly.
***
## Real-World Workflow
```text theme={null}
Review this model and summarize element counts, material
quantities, and any data quality issues.
```
*Agent reports element counts by type, flags 23 beams missing a fire rating.*
```text theme={null}
List the 23 beams missing a fire rating, with their IDs
and locations.
```
*Agent returns the list with IDs, levels, and coordinates.*
```text theme={null}
Tag all 23 of those beams with FireRating = 2HR under
Pset_BeamCommon. Show me the change set before saving,
then save as 'Model_Tagged.ifc'.
```
*Agent previews the batch, confirms, and saves the new file.*
```text theme={null}
Re-check the tagged model for data quality issues. Confirm
no beams are still missing a fire rating.
```
*Agent confirms the gap is closed.*
```text theme={null}
Run a quantity takeoff on the tagged model, then generate a
priced bill of quantities using MasterFormat, broken down
by storey.
```
*Agent runs the takeoff, classifies elements, and returns a priced BOQ with any coverage gaps flagged.*
***
## Tips for Success
* **Start with a summary** - Get the lay of the land before diving into edits or costing
* **Preview before saving** - Ask the agent to show you the change set first for anything non-trivial
* **Batch related edits** - Group similar tagging or property changes into one request so they apply as a single transaction
* **Name your outputs** - Tell the agent what to call the saved file so you can track revisions
* **Ask "what's missing"** - Gaps and warnings are often more actionable than raw counts
***
## Next Steps
Upload an IFC model and ask for a full review
[Go to app.stru.ai](https://app.stru.ai)
Take a model from quantity takeoff to a priced bill of quantities
Find and fix missing properties or unclassified elements in bulk
Upload two versions of a model and see what changed
Convert a Revit model to IFC to unlock full element-level analysis
Use **@** in prompts to search relevant standards
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting) to discuss your use case.
# ETABS & SAP2000 Agents
Source: https://docs.stru.ai/platform-guides/etabs-sap2000-agents
Build and analyze 3D structural models using natural language prompts
## Getting Started
The ETABS and SAP2000 agents let you build structural models through conversation. Describe what you want, and the agent creates the model automatically.
The agents work through the **Stru AI desktop app** running on the same computer where ETABS or SAP2000 is installed. The agent controls your local software directly, with your licenses, templates, and files. New to the desktop app? Start with [Install & Sign In](/desktop-app/install-and-sign-in), then come back here.
[Download the Stru AI desktop app](https://stru.ai/download) and install it on your machine with ETABS or SAP2000 ([step-by-step install guide](/desktop-app/install-and-sign-in)).
Run the Stru AI app on your computer. It connects your local ETABS/SAP2000 installation to the agent.
Sign in with your email. Then use the dropdown in the **top-left** corner to choose **ETABS Agent** or **SAP2000 Agent** for the software you want to drive.
Use the **Client** control in the **top-right** corner to connect the app to your local ETABS/SAP2000. A **green dot** means the client is connected and ready. From the same dropdown you can **Restart client** (reconnect) or **Stop client** (disconnect). The **Update** button keeps the app on the latest version. More detail: [Connecting ETABS & SAP2000](/desktop-app/connect-etabs-sap2000).
Open **Settings** (gear icon, top-right) to verify the app is connected with SAP2000/ETABS and to check/update the working directory. The agent will use this directory to save new models and access existing models.
You can chat with the agent in two ways:
**Option 1, in the app:** Once the client shows a green dot, type your request in the **Message the agent...** box at the bottom of the app window and start building. Everything runs against your local ETABS/SAP2000.
**Option 2, via browser:** Go to [app.stru.ai](https://app.stru.ai), select **ETABS Agent** or **SAP2000 Agent** from the top-left dropdown, then click the monitor icon with the green dot to connect to your computer app. Chat from the website while the agent drives your local software.
Models are created in your local ETABS/SAP2000. Save files directly to your machine using the working directory configured in the app settings, use your own templates, and leverage your local computing resources.
**Why local?** Full control over your files, access to your templates and section databases, fast performance, and everything stays on your machine.
**Pro Tip:** Use **@** to search building codes while writing prompts. Try `@ASCE 7` for wind loads or `@ACI 318` for concrete design.
### Agent in Action
Watch the SAP2000 Agent build a steel structure through the Stru AI desktop app:
The Stru AI app runs on your machine and connects to your local ETABS/SAP2000 installation. You chat through the app or your browser while the agent controls the software directly on your computer.
The interface shows:
* **Center:** Interactive 3D model views from SAP2000/ETABS - click to select elements for modification
* **Right panel:** Agent's explanation of what was built and validation summary
* **Bottom:** Task breakdown with completed (✓) and in-progress (⚡) steps
***
## ETABS vs SAP2000: Which Agent?
**Choose for:**
* Buildings (high-rise, concrete frames, shear walls)
* Floor diaphragms and vertical load distribution
* Building-specific seismic and wind design
* Story-based modeling workflows
**Choose for:**
* Bridges, trusses, space frames
* Industrial structures and towers
* Long-span systems and stadiums
* General-purpose structural analysis
***
## Writing Effective Prompts
### The Golden Rule
**Either be specific OR explicitly give the agent discretion.** Avoid vague prompts.
```text ✅ Good: Be Specific theme={null}
Create a 4-story building:
- Plan: 120ft x 80ft
- Bays: 4 @ 30ft in X, 4 @ 20ft in Y
- Story heights: 15ft ground, 12ft typical
- Columns: W14x120
- Beams: W21x50
- Units: kip-ft
```
```text ✅ Good: Give Discretion theme={null}
Create a 4-story office building, roughly 120ft x 80ft.
Use your engineering judgment for bay spacing, member
sizes, and story heights appropriate for office loads.
```
```text ❌ Bad: Vague theme={null}
Create a building with some beams and columns.
```
### Key Prompt Elements
Always include units in your first prompt:
✅ "Use kip-ft units for this model..."
Prevents unit confusion later.
For complex structures, work incrementally:
```text theme={null}
First, create the basic frame geometry.
[Review screenshot]
Now add X-bracing to perimeter frames.
[Review again]
Finally, apply gravity loads.
```
Specify load directions clearly:
✅ "Apply loads in gravity direction (downward)"
✅ "Wind loads in Global Y direction"
✅ "Distributed along member length"
***
## Common Use Cases
### Concrete Building Frame
```text theme={null}
Create a 5-story reinforced concrete frame:
- Plan: 100ft x 75ft
- 5 bays @ 20ft in X, 5 bays @ 15ft in Y
- Story height: 12ft typical
- Columns: 24"x24", Beams: 18"x24"
- Concrete: f'c = 4000 psi
- Apply loads: DL=120psf, LL=60psf
```
### Adding Shear Walls
```text theme={null}
Add concrete shear walls to the existing frame:
- Walls on gridlines A and D (perimeter)
- Wall thickness: 12"
- Height: Full building height
- Connect to existing frame with rigid connections
```
### Modifying Existing Model
**Option 1: Describe the changes**
```text theme={null}
Change all columns on levels 3-5 to 24"x30".
Keep levels 1-2 as 24"x24". Show before/after comparison.
```
**Option 2: Select and modify**
Click to select specific columns in the 3D viewer, then: *"Change these selected columns to 24"x30""*
### Floor Diaphragm Modeling
```text theme={null}
Add floor diaphragms at all levels:
- Slab thickness: 8"
- Diaphragm type: Rigid
- Include openings for stairs and elevator shafts
- Apply floor loads: DL=120psf, LL=60psf
```
### Steel Truss Bridge
```text theme={null}
Create a 100ft Warren truss:
- Span: 100ft, Depth: 12ft, Panel spacing: 10ft
- Top chord: HSS10x10x5/8
- Bottom chord: HSS8x8x1/2
- Web members: HSS6x6x3/8
- Supports: Pin at left, roller at right
```
### Space Frame Structure
```text theme={null}
Create a 60ft x 60ft space frame roof:
- Grid: 10ft x 10ft spacing
- Height: 15ft at center, 10ft at edges (sloped)
- Members: HSS4x4x1/4 for all elements
- Support: Columns at perimeter grid points
```
### Steel Frame with Bracing
```text theme={null}
Create a 3-story industrial steel frame:
- Plan: 80ft x 60ft, 4 bays @ 20ft, 3 bays @ 20ft
- Story heights: 20ft ground, 15ft typical
- Columns: W14x90, Beams: W18x35
- Add X-bracing on gridlines A and D, all stories
- Use HSS8x8x1/2 for braces
```
### Load Combinations
```text theme={null}
Apply gravity loads to all beams:
- Dead: 1.2 kip/ft (includes self-weight)
- Live: 0.8 kip/ft
- Wind: 40 psf lateral pressure
Create ASCE 7-22 load combinations for gravity and wind design.
```
***
## Advanced Usage
### Study and Recreate Existing Models
The agent can analyze existing models and recreate them with modifications:
```text theme={null}
Open 'Existing_Building.sdb' and study its geometry, sections,
and loads. Then create a similar model but with:
- 20% taller story heights
- Updated to ASCE 7-22 wind loads
- Member sizes optimized for new loads
```
**Use cases:** Modernize old models to new code provisions, create design variations, or standardize legacy projects.
### Compare Two Models
Compare different design options:
```text theme={null}
Compare 'Option_A.sdb' and 'Option_B.sdb':
1. Total steel weight difference
2. Drift ratios under lateral loads
3. Foundation reactions comparison
4. Cost implications of member size differences
```
**Use cases:** Design optimization, value engineering studies, structural system selection, and code compliance verification.
### Use Sketches and Floor Plans
Upload drawings to convey information:
```text theme={null}
I'm attaching a floor plan sketch. Create a 3-story model
based on this layout. Use W14 columns and W18 beams.
Story height: 12ft.
```
**What you can upload:** Hand-drawn sketches, PDF floor plans, marked-up elevations, or structural diagrams. The agent interprets dimensions, grid layouts, and structural intent from images.
### Parametric Design and Iterations
Rapidly generate design variations for optimization studies, value engineering, and sensitivity analysis.
**Lateral system comparison**
```text theme={null}
Model the same building with three lateral systems:
1. Perimeter moment frames
2. Interior braced frames
3. Concrete shear walls at core
Compare drift, period, material quantities, and foundation demands.
```
**Floor system optimization**
```text theme={null}
Create 4 variations of floor framing:
1. Post-tensioned slab (8" thick)
2. Two-way concrete slab (10" thick)
3. One-way joist system (24" depth)
4. Composite steel deck (3" deck + 12" beams)
Compare cost, weight, and floor-to-floor height.
```
**Building height study**
```text theme={null}
Create iterations for 4, 6, 8, and 10 story variations:
- Keep same footprint (120ft x 80ft)
- Adjust column sizes for increased height
- Compare seismic base shear and drift
- Report steel/concrete quantities per floor
```
**Truss depth optimization**
```text theme={null}
Create 3 models with truss depths of 10ft, 12ft, and 15ft:
- Same 120ft span
- Keep all other parameters constant
- Report: Deflections, steel weight, connection complexity
```
**Bridge cable configuration**
```text theme={null}
Model cable-stayed bridge with different cable patterns:
1. Fan arrangement (all cables from tower top)
2. Harp arrangement (parallel cables)
3. Semi-fan hybrid
Compare deck moments, tower forces, and cable quantities.
```
**Member size optimization**
```text theme={null}
Create 5 design iterations:
Base case: Space frame with HSS4x4x1/4
Iterations:
1. HSS5x5x5/16 (heavier)
2. HSS3x3x3/16 (lighter)
3. Mixed sizing (perimeter vs interior)
4. Optimize for minimum weight under deflection limit
Save each and compare weight/deflection tradeoffs.
```
The agent handles the repetitive modeling work, letting you focus on engineering decisions.
***
## Best Practices
**Always specify units first**
Include units in your opening prompt: *"Create a model using kip-ft units..."*
**Build geometry before loads**
Create structure first → Review screenshot → Apply loads → Verify patterns → Run analysis
**Save incrementally**
Save at major milestones: *"Save as 'Building\_BaseFrame\_v1.sdb' before we modify the lateral system"*
**Be explicit about changes**
✅ *"Change columns on levels 3-5 only, keep 1-2 as-is"*
❌ *"Update some columns"*
**Use filters for bulk edits**
Target specific elements: *"Change all beams longer than 30ft to W21x62. Keep beams under 30ft as W18x35."*
**Select elements directly in the model**
Click to select frames, joints, or areas in the ETABS/SAP2000 viewer, then ask the agent to modify your selection: *"Change these selected beams to W21x50"*
**Group similar loads together**
Apply multiple load cases in one prompt: *"Apply to all floor beams: Dead 1.0 kip/ft, Live 0.6 kip/ft, Snow 0.8 kip/ft (roof only)"*
**Use standard combinations**
The agent knows code requirements: *"Create ASCE 7-22 load combinations for gravity and wind design"*
**Verify with visuals**
Request screenshots with load arrows to confirm the pattern is correct.
***
## Troubleshooting
### Model Doesn't Look Right
```text theme={null}
Show me:
- Isometric view
- Plan view at level 2
- Elevation along gridline A
```
```text theme={null}
List all frame members with their coordinates and sections.
```
```text theme={null}
This isn't quite right. Let's create a new model.
This time, use 4 bays @ 25ft instead of 5 bays @ 20ft.
```
### Agent Seems Stuck
If the agent stops responding, keeps repeating the same step, or gets caught in a loop, work through the fixes below **from top to bottom**: start with a prompt nudge, and only restart the client or model if prompts don't help.
**Recovery ladder:** (1) Ask for status → (2) Redirect with a prompt → (3) Simplify or break it down → (4) Start the task from scratch → (5) Restart the client → (6) Close the model and start a fresh session. Each step is a bigger reset than the last.
**Try a Prompt First**
See where the agent is before changing anything:
```text theme={null}
What's the current status? Which step are you on, and
are you stuck or waiting on something?
```
Nudge the agent to step back instead of pushing the same path:
```text theme={null}
This approach doesn't seem to be working. Stop and
rethink it. Explain a simpler plan before you make any
more changes, then proceed once the plan looks right.
```
Strip the task down to the essentials and add detail later:
```text theme={null}
Let's pause. Just create the basic frame geometry
without loads for now.
```
Instead of one complex prompt, use a sequence and review between steps:
1. Create geometry
2. Add lateral system
3. Apply loads
4. Run analysis
If the model is in a bad state, have the agent abandon it and rebuild cleanly:
```text theme={null}
Let's start over from scratch. Discard the current
progress, create a new model, and rebuild it step by
step. Confirm each step with a screenshot before moving on.
```
**Reset the Session**
If prompts aren't getting through, the connection between the app and ETABS/SAP2000 may have hung. Reset it.
Open the **Client** dropdown in the top-right of the app and choose **Restart client**. This reconnects the app to ETABS/SAP2000 without closing your model. Wait for the **green dot**, then send your prompt again.
If a restart doesn't help, the ETABS/SAP2000 model itself may be in a stuck state:
1. **Stop client** from the Client dropdown.
2. Close the model in ETABS/SAP2000 (save first if you want to keep it).
3. Reopen ETABS/SAP2000, then **Restart client** and wait for the green dot.
4. Ask the agent to reopen your saved model, or start a fresh build.
A clean model and a fresh client connection clears the large majority of stuck states.
If the agent is still stuck after a full restart, click **Update** (top-right) to make sure you're on the latest app version, then try again. If the problem persists, email **[support@stru.ai](mailto:support@stru.ai)** with a short description and a screenshot.
### Loads Not Applied Correctly
```text theme={null}
List all load patterns and show which members have
loads in the DEAD case.
```
```text theme={null}
Verify the loads are applied downward (gravity).
Reapply if the direction is wrong.
```
```text theme={null}
Screenshot with load arrows visible.
```
***
## Real-World Workflow
Complete design sessions showing iteration and refinement:
```text theme={null}
Create a 4-story office building:
- 150ft x 100ft plan
- 5 bays @ 30ft in long direction
- 4 bays @ 25ft in short direction
- Story heights: 15ft ground, 13ft typical
- Use engineering judgment for member sizes
- Units: kip-ft
```
*Agent creates model with W14x176 columns, W24x62 beams*
```text theme={null}
Beams seem heavy. Try W21x50 for levels 2-4,
keep W24x62 at ground only.
```
*Agent updates sections*
```text theme={null}
Make perimeter frames on gridlines A and E moment-connected
for lateral resistance.
```
*Agent modifies connections*
```text theme={null}
Floor loads:
- Dead: 100psf (slab + MEP + ceiling)
- Live: 50psf (office)
- Roof: Dead 80psf, Live 20psf
Create ASCE 7 gravity combinations.
```
*Agent applies loads and combinations*
```text theme={null}
Before analysis, show:
1. Isometric with loads visible
2. Total applied loads by level
3. List of load combinations
```
*Agent provides verification package*
```text theme={null}
Save as 'Office_Gravity_Rev1.edb'
```
*Agent saves and provides download link*
```text theme={null}
Create a 150ft Pratt truss bridge:
- Span: 150ft, Depth: 20ft
- Panel spacing: 15ft (10 panels)
- Top chord: HSS12x12x5/8
- Bottom chord: HSS10x10x1/2
- Verticals/diagonals: HSS8x8x3/8
- Units: kip-ft
```
*Agent creates truss geometry with member assignments*
```text theme={null}
Add bridge deck:
- Width: 30ft
- Composite steel girders @ 10ft spacing
- Connect deck to top chord at panel points
```
*Agent adds deck framing*
```text theme={null}
The bearing at the right end needs to allow thermal
expansion. Change it to a guided roller support allowing
movement in the longitudinal direction only.
```
*Agent modifies boundary conditions*
```text theme={null}
Apply loads:
- Dead: Deck self-weight + 25 psf utilities
- HL-93 live load pattern on deck
- Wind: 30 psf lateral on exposed area
Create AASHTO load combinations.
```
*Agent applies bridge loading*
```text theme={null}
Show me a summary of member forces and highlight any
members with high stress ratios. Focus on diagonals and
chord members.
```
*Agent provides force summary with critical members flagged*
```text theme={null}
Save as 'Truss_Bridge_Rev1.sdb'
```
*Agent saves and provides download link*
***
## Tips for Success
* **Iterate freely** - Don't expect perfection first try. Refine with follow-ups: *"Can you adjust the bay spacing to be more uniform?"*
* **Interactive selection** - Click elements in the 3D viewer to select them, then ask the agent to modify your selection
* **Request screenshots** - Ask for visual verification at key stages: *"Show isometric view to confirm bracing layout"*
* **Upload references** - Attach floor plans, sketches, or existing models to guide the agent and convey complex information visually
* **Compare options** - Generate multiple design variations quickly for value engineering and optimization studies
***
## Next Steps
Install the Stru AI app and pair it with your account.
The Client pill, working folders, and detected versions.
Create a model from a floor plan or structural drawing.
Tag ASCE 7, ACI 318, AISC 360, and IBC in your prompts.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting) to discuss your use case.
# Review Agent
Source: https://docs.stru.ai/platform-guides/review-agent
Chat with your drawing set: trace details, answer questions across sheets, and verify review findings
## Overview
The **Review Agent** is the agent you talk to *about* a set of construction drawings. Point it at a project folder of drawings and specs and it answers the way a sharp reviewer would: it reads the sheets, follows callouts and cross-references between them, pulls up the exact detail you're asking about, and cites the code clause behind its answer.
**The Review Agent is not the same thing as a Drawing Review.** A [Drawing Review](/how-to/drawing-review) is a formal quality assurance/quality control (QA/QC) run you launch from the Files page, [billed per page](/how-to/review-pricing): it sweeps every sheet in a folder and produces a findings report. The Review Agent is the conversation side. Ask it anything about your drawings, including questions about the findings a Drawing Review produced. The Drawing Review is the red-line pass; the Review Agent is the reviewer you interrogate afterwards.
## What Can You Do With It?
"Where is the typical shear wall boundary detail?" The agent finds the sheet, the detail, and the note.
Follow a section cut or detail bubble to the sheet it lives on, and check the reference actually resolves.
Take a finding from a completed Drawing Review and have the agent re-check it against the drawings and the code.
Upload an RFI response and ask whether it answers the question and matches the drawings.
Cross-check spec sections against the drawings, or one revision against another, and get the inconsistencies listed.
Ask for a crop of a specific detail or note and the agent clips that region of the sheet into the chat.
Answers cite the sheet, the detail, and the clause so you can verify them at the source. Engineering judgment and responsibility stay with you.
## Getting Started
Open [app.stru.ai](https://app.stru.ai) and pick **Review Agent** from the agent dropdown in the top-left corner.
A *project* is a folder in your [Files area](/how-to/file-management) that holds the drawings and documents for a job. The Review Agent works inside one project at a time, so it knows which drawing set you mean. Use the [**Select project** pill](/how-to/chat-input#the-project-picker) in the message box to pick one, or create a new project from the same menu.
If your drawings aren't in a project yet, upload them to a folder first: the [File Management guide](/how-to/file-management) shows how.
Ask the way you'd ask the engineer who did the review. Name the sheet or detail when you know it. When you don't, finding it is the agent's job.
## Common Workflows
### Ask questions about the drawings
```text Examples theme={null}
Which sheets show the second-floor framing, and what's the
typical beam size?
Where does detail 5/S-501 get called out, and does the base
plate thickness match the schedule?
What's the specified concrete strength for the shear walls,
and is it consistent between the general notes and the schedule?
```
The agent reads the actual sheets, not just the file names, and answers with the sheet and detail references included, so you can flip to the source and confirm.
### Verify a finding from a Drawing Review
After a [Drawing Review](/how-to/drawing-review) completes, its findings live with the project, and the Review Agent can see them. Pick the same project the review ran on and interrogate any finding:
```text Examples theme={null}
The review flagged a missing weld size on detail 3/S-402.
Is that right, or is it covered by a general note?
Walk me through finding #12. Show me the detail it's talking
about and the code clause it cites.
```
The agent re-checks the finding against the drawings themselves and tells you whether it holds up, with the evidence.
### Check an RFI response
Attach the response, or tag it with **@** if it's already in the project:
```text Example theme={null}
@RFI-014_Response.pdf Does this response actually resolve the
conflict between the foundation plan and S-501? Anything left
open?
```
## Good to Know
The Review Agent never launches a formal Drawing Review on its own. When you need the full QA/QC sweep with a findings report, launch it from the Files page: the [Drawing Review guide](/how-to/drawing-review) walks through it. Then come back here to dig into the results.
The agent needs to know which drawing set you're talking about, so the message box asks you to pick a project before your first message. Your choice sticks for the conversation.
By default the Review Agent answers in the chat. If you want the output as a document (a comment summary, a spec-comparison table), name the format and it produces the file.
## Next Steps
Launch the formal QA/QC review this agent helps you interrogate.
Set up the project folder your drawing set lives in.
Tag drawings and specs without re-uploading them.
Draft the RFI once you've confirmed the issue is real.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Structural Agent
Source: https://docs.stru.ai/platform-guides/structural-agent
Generate calculation packages, check designs against code, build spreadsheets, and draft engineering documents with the Structural Agent
## Overview
The **Structural Agent** is the general-purpose engineering assistant in Stru AI, and the agent you start on when you open [app.stru.ai](https://app.stru.ai). Describe the task, attach or tag the files it needs, and the agent researches, calculates, and builds the deliverable.
An *agent* is an AI assistant that does the work, not just the talking: it reads your files, searches design codes, runs calculations, and produces documents (calc sheets, spreadsheets, PDFs) you download and use.
**You are the engineer of record.** The agent drafts and calculates; you review and take responsibility. Check the code references and the numbers before anything leaves your desk. Every calc sheet is laid out to be checked line by line.
***
## What Can You Do With It?
Describe a design check (a beam, a weld, a base plate) and get a formatted, unit-aware calc sheet to download and check
Ask code questions and get answers backed by the cited clause: ACI, AISC, ASCE, and regional standards
Generate a new Excel workbook, or upload your company's existing sheet and have the agent explain or extend it
Give a project address and get wind, seismic, snow, and other design parameters for your risk category and site class
Point it at a drawing sheet and get a ready-to-review RFI or RFA as a PDF: see the [step-by-step guide](/how-to/generate-rfi-rfa)
Keep your templates in your [Standards folder](/how-to/standards-folder) and the agent follows your company's formatting automatically
***
## Getting Started
Go to [app.stru.ai](https://app.stru.ai). The Structural Agent is the default. Confirm which agent is active in the dropdown at the top-left corner.
The selector next to the agent name sets which family of building codes the agent works from: US, Eurocode, Australia/NZ, Canada, Philippines, or Singapore. This also filters which code documents appear when you type **@** in the message box.
Type what you need in the message box, or use one of the suggestion cards to see what a good prompt looks like. Attach the files the agent should work from (drawings, spreadsheets, reports) with the **+** button or by dragging them onto the page. The [Using the Chat Input](/how-to/chat-input) guide covers every way to get files and instructions in.
The agent shows its progress while it works. You'll see a step list for longer tasks. Documents it builds open live in the [Canvas](/how-to/canvas) beside the chat, and finished files come back as download links. Everything is also saved to your [Files area](/how-to/file-management) automatically.
***
## Common Workflows
### Get a code-backed answer
Ask the question the way you'd ask a colleague, and name the code if you have one in mind:
```text Example theme={null}
What's the minimum development length for a #6 bottom bar,
uncoated, normalweight 4000 psi concrete, per ACI 318-19?
State the modification factors you assume and show the calculation.
```
The agent answers with the governing clause cited (here, ACI 318-19 §25.4.2) and lists the modification factors it applied: bar location, coating, lightweight concrete, spacing and cover. Development length depends on all of them, so the assumptions are stated where you can check them.
Type **@** in the message box to tag a specific code document directly. The [Mentions guide](/how-to/mentions) shows how the picker works.
### Build a calculation package
Describe the element, the loads, and the check you need:
```text Example theme={null}
Create a fillet weld capacity calc: E70XX electrode, 1/4 in leg,
10 in weld length, 35 kip required shear. LRFD per AISC 360-22.
```
The agent drafts the calc sheet live in the Canvas beside the chat, where you can watch each section appear: project reference, code references, calculations, and the final design check.
When it finishes, the deliverables arrive as download links in the chat: the calc file itself, a PDF report, and supporting files.
### Work with spreadsheets
The agent builds new Excel workbooks and reads the ones you already have:
```text Create a new workbook theme={null}
Build a spreadsheet that checks bearing capacity for a strip
footing: inputs for width, depth, soil friction angle, and
cohesion, with the Terzaghi factors calculated.
```
```text Analyze an existing one theme={null}
@Retaining_Wall_Design.xlsx Walk me through this spreadsheet.
What are the inputs, what does it check, and are there any
formulas that look off?
```
### Look up site hazard data
```text Example theme={null}
Get the wind and seismic design parameters for 1600 4th Ave,
Seattle, WA 98101. Risk Category II, Site Class D.
```
The agent returns the design parameters for the location, ready to feed into your load calcs.
### Draft an RFI or RFA from a drawing
Tag the drawing sheet, describe the question or proposed change, and the agent reads the sheet and drafts the document as a PDF. This workflow has its own walkthrough: [Generate RFIs & RFAs](/how-to/generate-rfi-rfa).
***
## Tips for Better Results
Name the element, the loads, the material, and the code edition. "Check this beam" gets a generic answer; "check this W16x40, 28 ft span, 1.2 klf total factored load, A992, AISC 360-22 LRFD" gets a real calc.
The agent reads drawings, specs, and spreadsheets. Give it the actual document instead of describing it from memory. Files already in your Files area can be tagged with **@** so you never upload the same sheet twice.
If your company has a calc-sheet format, report boilerplate, or QA notes, put them in your [Standards folder](/how-to/standards-folder). With **Formatting standards** switched on in the **+** menu, the agent follows them automatically.
Bigger deliverables take several minutes. The agent shows a task list and progress while it works. You can keep typing follow-ups; press Enter and they'll be answered as soon as the current task finishes.
The agent drafts and calculates; you review. Check the code references and the numbers before anything leaves your desk. Every calc sheet is laid out so it can be checked line by line.
***
## FAQ
Every conversation gets its own folder under **Documents** in your Files area, and generated deliverables land there automatically. See [File Management](/how-to/file-management) for how the folders are organized.
A built-in library of design standards covering the regions in the design standard selector. Type **@** in the message box to see the exact documents and editions available for your selected region; that list is the source of truth. Every answer cites the clause it used, so you can verify against the code text.
Yes. Anything you upload or keep in your [Standards folder](/how-to/standards-folder) works: templates, past calcs, QA checklists, marked-up drawings.
The Structural Agent is the generalist. For driving ETABS or SAP2000 on your desktop, use the [ETABS & SAP2000 Agents](/platform-guides/etabs-sap2000-agents); for IFC/Revit model work, the [BIM Agent](/platform-guides/bim-agent); for Q\&A over a drawing set, the [Review Agent](/platform-guides/review-agent).
***
## Next Steps
Every way to type, dictate, and attach files
[Read the guide](/how-to/chat-input)
The live workspace where your documents take shape
[Read the guide](/how-to/canvas)
Turn a drawing sheet into a ready-to-send RFI or RFA
[Read the guide](/how-to/generate-rfi-rfa)
Make the agent follow your company's formats
[Read the guide](/how-to/standards-folder)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Branded Reports
Source: https://docs.stru.ai/workflows/branded-reports
Set your header fields and company logo once, and every calc sheet and report comes out on your firm's letterhead
## Your Letterhead, Every Time
Every calc sheet the [Structural Agent](/platform-guides/structural-agent) produces carries a full project header, and you control every field in it: project name, project number, project task, calc by, calc date, checked by, checked date, and the project address, plus your company logo pulled from your [Standards folder](/how-to/standards-folder). Set the fields and the logo once, and every [Mathcad sheet](/workflows/mathcad-calc-sheets), [Excel workbook](/workflows/excel-spreadsheets), and PDF report comes out on your firm's letterhead.
Here is the header on a finished calc sheet:
***
## The Header Fields
| Field | Example |
| -------------- | ----------------------------------- |
| Project name | Office Building Demo |
| Project number | 24-1042 |
| Project task | Fillet Weld Capacity Design |
| Calc by | J. Doe, PE |
| Calc date | 07/06/2026 |
| Checked by | R. Roe, PE |
| Checked date | 07/07/2026 |
| Address | 1600 4th Ave, Seattle, WA 98101 |
| Logo | logo.png from your Standards folder |
**Calc by and checked by are your QA trail.** Fill them the way your firm's review process expects: you are the engineer of record, and the header carries that on every page.
***
## One-Time Setup
Open **Files** from the account menu and find the Standards folder, marked with the book icon. Upload your **logo** (a PNG with a transparent background works best) along with anything else that defines your format: a report template, a sample calc package, formatting notes.
No Standards folder yet? Right-click any folder you can edit in [Files](/how-to/file-management) and choose **Set as Standards Folder**. Organization-wide setups are covered in [Your Standards Folder](/how-to/standards-folder).
Click the **+** button in the message box. **Formatting standards** shows a toggle, on by default. With it on, the agent reads your Standards folder before it formats anything: no tagging needed in each prompt.
Tell the agent the fields once and keep them:
```text Example: header defaults theme={null}
Use these header fields on all calc sheets for this project:
Project: Office Building Demo
Project number: 24-1042
Calc by: J. Doe, PE
Checked by: R. Roe, PE
Address: 1600 4th Ave, Seattle, WA 98101
Logo: logo.png from the Standards folder.
Save this as a standard.
```
The header block lands in your Standards folder, and future conversations pick it up automatically. The task and the dates change with every calc, so leave those to each request.
***
## Generate the Deliverable
Ask for the calc or report the way you normally would: the header and formatting come from your standards. Set the task per calc, and override any field inline when a sheet needs something different:
```text Example: calc package theme={null}
Create the retaining wall design calcs for the north wall: 10 ft
retained height, level backfill, 120 pcf soil, no surcharge,
ACI 318-19, US units. Project task: North Retaining Wall.
```
```text Example: field report theme={null}
Write up the findings from @Site_Walk_Photos.pdf as a field
observation report on our template, with the standard header.
```
The finished document lands in the chat as a download link and in your [Files area](/how-to/file-management) automatically. The same setup carries to [RFIs and RFAs](/how-to/generate-rfi-rfa): the agent follows the forms it finds in your Standards folder.
***
## One-Off Formats
For a client format you will use once, skip the Standards folder: attach the template with the **+** button and reference it in the prompt.
```text Example theme={null}
@Client_Report_Template.docx Use this template for this report
instead of our standard format.
```
Attachments and tagging are covered in [Using the Chat Input](/how-to/chat-input) and [Mentions & Attachments](/how-to/mentions).
***
## Next Steps
Where the logo and templates live, and how the agent uses them
[Standards Folder guide](/how-to/standards-folder)
The calc package that wears this header
[Mathcad Calc Sheets guide](/workflows/mathcad-calc-sheets)
Workbooks with the same header rows built in
[Excel Spreadsheets guide](/workflows/excel-spreadsheets)
The brief that fills the sheet under the header
[Design Checks guide](/workflows/design-checks)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Build Models in ETABS & SAP2000
Source: https://docs.stru.ai/workflows/build-etabs-sap-models
Describe the structure and the agent builds it live in the ETABS or SAP2000 on your machine: grids and stories first, then framing, then loads, then the run
## From Brief to Running Model
Describe the structure and the agent builds it in the ETABS or SAP2000 installed on your machine, live on your screen, with your licenses and your section databases. The connection runs through the Stru AI desktop app: set it up once with [Connecting ETABS & SAP2000](/desktop-app/connect-etabs-sap2000), then model by conversation.
Jobs this page covers:
* **Build a model from a brief**: geometry, sections, loads, and combinations from one written description
* **Build from structural drawings**: attach the framing plans and schedules and model from them
* **Build from an IFC model**: turn a BIM model into an analysis model
* **Build a bridge in SAP2000**: the same staged pattern, applied to spans instead of stories
Here the agent builds a braced steel frame from a one-paragraph brief, ticking off its task list as the model grows:
This page is the workflow. For prompting patterns, ETABS vs SAP2000 selection, and recovery when a session stalls, see the [ETABS & SAP2000 Agents guide](/platform-guides/etabs-sap2000-agents).
***
## Set Up Once
The agent drives the software on the machine where it is installed, so start with [Install & Sign In](/desktop-app/install-and-sign-in) on that machine.
The **Client** pill in the app header shows a green dot when the app is connected to your ETABS or SAP2000. Details in [Connecting ETABS & SAP2000](/desktop-app/connect-etabs-sap2000).
Choose **ETABS Agent** for buildings or **SAP2000 Agent** for bridges, trusses, and general structures, from the dropdown in the top-left corner.
***
## Stage the Build
A model built in stages is a model you can check at every step. Give the complete brief up front, then have the agent build one stage at a time: grids and stories, then framing, then loads, then the analysis run. Each stage gets verified before the next builds on it.
Geometry, sections, materials, code, and units, all in the first message. A complete brief gets a complete model; anything you leave out, the agent has to assume.
```text Example: model brief theme={null}
Build a 6-story office building in ETABS. Work in stages and
wait for my go-ahead between stages.
- Units: kip, ft
- Grids: 5 bays @ 30 ft in X, 3 bays @ 28 ft in Y
- Stories: 15 ft ground, 13 ft typical
- System: steel moment frames on the perimeter, W14 columns,
W24 girders, W16 infill beams
- Materials: A992 steel, 4000 psi concrete on metal deck
- Code: ASCE 7-22 load combinations
Start with grids and stories only.
```
Everything else hangs off the grid, so confirm it before any framing exists: *"Show me a plan view and an elevation before we continue."* Fixing a grid now takes one message; fixing it under a finished model takes a rebuild.
Columns, then beams, then walls and slabs, one system per message. After each: a screenshot, a quick scan, then the go-ahead. To change something, say exactly which members: *"Change the girders on levels 2 to 4 to W24x76, keep the roof as is."*
Apply gravity first, then lateral, and ask for a screenshot with load arrows visible to confirm the pattern and direction. If the wind and seismic demands still need deriving, [Wind & Seismic Load Calcs](/workflows/wind-seismic-loads) covers getting them from your site and code. Before moving on: *"List every load case and combination you have not applied yet."*
Run the analysis, then have the agent walk you through the results in the model: *"Walk me through the governing drift: story, combination, and value. Then give me the base reaction totals so I can compare them with my hand tally."* Save with a versioned name: *"Save as Office\_Building\_Demo\_v1.EDB."*
**One stage per request.** "Build the whole building" produces a model you have to reverse-engineer to trust. Staged builds produce a model you watched grow, with a checkpoint at every step.
***
## Build From Your Drawings
Attach the framing plan and reference it with **@** so the agent models from your sheet and your numbers. The [Mentions guide](/how-to/mentions) covers tagging files already in your project.
```text Example: model from a plan theme={null}
@S-201_Level2_Framing.pdf Build levels 1 to 3 in ETABS from this
plan. Use the grid dimensions and member sizes shown on the sheet.
Ask me before assuming anything the sheet does not show.
```
Work sheet by sheet, the way the set is organized: the framing plan for geometry, the column schedule for sections, the general notes for materials. Referencing the sheet in every request keeps the model traceable to the drawing it came from.
***
## Build From an IFC Model
When the geometry already exists as a BIM model, have the [BIM Agent](/platform-guides/bim-agent) read the IFC first and turn it into a modeling brief.
```text Example: IFC to modeling brief theme={null}
@Office_Building_Demo.ifc List the levels, grid lines, and every
column and beam with its section and material. Format the output
as a modeling brief I can hand to the ETABS Agent.
```
The BIM Agent opens the model in a viewer beside the chat while it reads the file:
Take the brief it produces into an ETABS or SAP2000 Agent conversation and stage the build as above. You review the brief in between, which is exactly where a geometry error is cheapest to catch.
***
## A Bridge in SAP2000
The staged pattern carries over: alignment and supports first, then the superstructure, then loads.
```text Example: bridge brief theme={null}
Build a 3-span continuous steel plate girder bridge in SAP2000.
Work in stages and confirm each stage with a screenshot.
- Units: kN, m
- Spans: 35 m + 45 m + 35 m
- Cross-section: 4 girders at 3.0 m spacing, 250 mm composite deck
- Supports: bearings at abutments and piers, continuous girders
over the piers
- Loads come after geometry is confirmed: self-weight,
superimposed dead 2.5 kPa, then AASHTO HL-93
Start with the girder layout and supports.
```
Trusses, space frames, and cable systems follow the same rhythm; the [SAP2000 examples](/platform-guides/etabs-sap2000-agents) show briefs for each.
***
## Verify As You Go
Three habits keep a staged build honest:
* **Screenshot every stage.** A plan and an elevation after each stage catches misplaced grids and missing members while they are one message deep.
* **Ask what is missing before the run.** *"List every load case and combination you have not applied yet"* turns the gap between intent and model into a to-do list.
* **Read the numbers back after the run.** Have the agent open the saved file and report the governing drift and reaction totals, then compare them against your expectations.
You are the engineer of record: the model that goes forward is the one you have checked, and a staged build gives you a checkpoint trail to check it against. For a deeper verification pass on the finished model, export the results and run [Check an Existing Model](/workflows/check-existing-model).
***
## Next Steps
The Client pill, working folders, and detected versions.
Prompting patterns, examples, and stall recovery.
Export the results and verify them against code limits.
Derive the lateral loads before you apply them.
[Wind & Seismic Load Calcs](/workflows/wind-seismic-loads)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Check an Existing Model
Source: https://docs.stru.ai/workflows/check-existing-model
Export the results from ETABS or SAP2000, attach the export, and get checks that trace back to your own numbers
## Your Numbers, Checked
The auditable way to verify a model: export the results tables from ETABS or SAP2000 to Excel or CSV, attach the export, and ask for the check. The agent works from your numbers, and every conclusion traces back to a row in your export, which is what makes the check reviewable by anyone who picks it up after you.
The pattern works on any model you can export from: your own, a subconsultant's, or a legacy model you inherited. Common checks:
* **Verify drift limits**: every story against the code allowable, with the governing story called out
* **Spot-check member DCRs**: find the members near or over 1.0 and see what drives them
* **Sanity-check reactions**: total the base reactions and compare them with your hand tally of the gravity load
***
## The Pattern
In ETABS or SAP2000, export the results tables you need to Excel or CSV: story drifts for a drift check, joint reactions for a reaction check, the steel or concrete design summary for DCRs. Export only the load cases and combinations that matter for the question; a focused export makes a focused check.
Attach the file with the **+** button, or tag it with **@** if it is already in your Files ([Mentions guide](/how-to/mentions)). Then open with:
```text theme={null}
List the files you can see and the tables inside the workbook
before you start.
```
The reply confirms the agent is working from your export, sheet by sheet, before any checking begins. With the export attached, the opening message looks like this:
Code and edition, units, story heights for drift ratios, which combinations are seismic and which are wind, and what limit applies. The export holds the results; you hold the meaning. A complete brief gets a complete check.
Drift first, then DCRs, then reactions. Each check gets its own request and its own traceable answer. Batching them into one prompt blurs which number answered which question.
***
## Three Checks That Work Well
```text Example: drift check theme={null}
Attached: Story_Drifts.xlsx, exported from ETABS, seismic
combinations only. Story heights: 15 ft ground, 13 ft typical.
Check every story against the ASCE 7-22 allowable story drift
for Risk Category II. Quote the section text you used for the
limit. Flag any story over the limit and show the three worst
ratios with story, combination, and direction.
```
Asking for the quoted section text makes the answer reviewer-ready: the limit, the clause, and your numbers, all in one place.
```text Example: DCR spot check theme={null}
Attached: Steel_Design_Summary.xlsx from ETABS.
List every member with a DCR above 0.95, grouped by story and
section. For the worst five, tell me which check governs
(flexure, shear, combined) from the columns in the export.
```
Any member that deserves a closer look can then get a full independent check from first principles: [Design Checks](/workflows/design-checks) covers that pattern.
```text Example: reaction sanity check theme={null}
Attached: Joint_Reactions.xlsx from SAP2000.
Sum the vertical reactions for the dead load case and compare
with my hand tally: 6 floors x 12,000 sq ft x 95 psf, roughly
6,840 kips plus wall loads. Explain any difference over 2
percent and show which columns carry the most load.
```
A reaction total that matches your hand calc is the fastest global confidence check a model can get.
***
## Push Past the First Answer
Two follow-ups turn a check into an audit:
* **Have it read the governing number back.** *"Walk me through the governing story: which combination, which direction, and the exact rows in my export that produced the ratio."* The answer should point at your data, row by row.
* **Ask what was not checked.** *"List every check you did not run on this export."* The reply becomes the plan for the next export: torsional irregularity, uplift, service-level drift, whatever the first pass left out.
When the checks are done, ask for the summary as an Excel check sheet you can file with the calc package: [Design Spreadsheets in Excel](/workflows/excel-spreadsheets) covers the deliverable side. You are the engineer of record; the export, the checks, and the model stay under your control, which is the point of this pattern.
***
## Next Steps
Full independent checks for the members the export flagged.
Turn the check results into a workbook for the calc package.
The staged workflow for building the model in the first place.
Drive the software live from the desktop app.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Code Questions
Source: https://docs.stru.ai/workflows/code-questions
Ask a code question with the code, edition, and jurisdiction named, and get the answer with the clause text quoted, ready for a submittal response or a reviewer reply
## The Answer, With the Clause Quoted
Name the code, the edition, and the jurisdiction in your question, and ask the agent to quote the clause text it used. The answer comes back with the governing section cited and quoted, ready to drop into a submittal response or a reply to a reviewer comment.
The pattern works across disciplines: an architect confirming a fire rating, a civil engineer checking cover on a buried structure, an engineer settling which load combination governs. Same question shape every time.
```text A reviewer-ready question theme={null}
What is the minimum concrete cover for the earth-side face of a
cast-in-place retaining wall, per ACI 318-19? Quote the table
entry and state the exposure condition you assumed.
```
The answer comes back with the table entries quoted, the section number cited, and the assumptions stated where you can check them:
**Ask for the quote every time.** A quoted clause you can read beside your response is reviewer-ready. A bare section number still sends you back to the shelf.
***
## Find the Code First
The design standards the agent works from are listed inside the app, filtered to your region. Check there before you write the question.
The selector next to the agent name at the top left sets which family of codes the agent works from, and filters what the **@** picker shows.
Type **@** in the message box. The green **Standards** section lists the design codes available for your selected standard, and typing after the **@** searches them. That list is live in the app and is the source of truth for what is available in your region. The [Mentions guide](/how-to/mentions) covers the picker in full.
Press **Enter** on a code to tag it as a green chip, which pins the exact document. Naming the code and edition in the prompt works too. Either way, the answer cites the document you asked for.
***
## Questions That Get Reviewer-Ready Answers
The same shape works from any desk:
```text Fire rating and egress theme={null}
Per IBC 2021, what is the maximum common path of egress travel
for a Group B occupancy with an automatic sprinkler system?
Quote the table entry and any footnotes that apply.
```
```text Load combinations theme={null}
Which ASCE 7-22 LRFD load combination governs a low-slope roof
carrying dead, roof live, and snow load? Quote the candidate
combinations and show why the governing one governs.
```
Each one names the code and edition, says exactly what the answer must contain, and asks for the quoted text. When the jurisdiction matters (a local amendment, a state code), name the city or authority too.
***
## Push Past the First Answer
A good answer is a starting point. Two follow-ups turn it into a finished response:
* **Ask what a reviewer would raise.** "What other sections could a reviewer cite against this detail?" surfaces the questions before the comment letter does.
* **Work from the actual comment.** Attach the reviewer's comment letter or the marked-up sheet, or tag it with **@** if it is already in your [Files area](/how-to/file-management), and ask for a point-by-point response with citations.
You are the engineer of record. The agent quotes the clause; you confirm the quote against the code text before it carries your response.
***
## Next Steps
How the @ picker works: standards, files, and folders
[Mentions guide](/how-to/mentions)
Work in your own language and jurisdiction
[Local Codes & Languages](/workflows/local-codes-languages)
Site hazard parameters by address, with references
[Wind & Seismic Loads](/workflows/wind-seismic-loads)
Turn a code answer into a full element check
[Design Checks](/workflows/design-checks)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Connection Design
Source: https://docs.stru.ai/workflows/connection-design
Brief one connection at a time with member sizes, factored loads, material and bolt grades, and the code, and get a connection calc you can check line by line
## One Connection Per Request
Shear tabs, base plates, splices, welds: give the agent the member sizes, the factored loads, the material and bolt grades, and the code, and it returns a connection calc sheet laid out to be checked line by line. Design one connection per request: the shear tab lands, then the base plate, then the splice, each building on the last.
The same brief works wherever the connection lives: a beam-to-column shear tab in an office building, a base plate under a transit canopy column, a welded splice on a pipe rack.
```text A complete connection brief theme={null}
Design a bolted shear tab connection: W18x35 beam to W12x65
column flange, 42 kip factored end reaction. A992 members,
A36 plate, 3/4 in A325-N bolts, E70XX fillet welds.
AISC 360-22 LRFD. Cite the spec section for every limit state
you check.
```
"Check this connection" gets a generic answer. The brief above gets a calc you can sign off on.
***
## Step-by-Step
Type **@** in the message box and tag the framing plan or connection detail from your [Files area](/how-to/file-management), so the agent works from your geometry and your numbers instead of a description. The [Mentions guide](/how-to/mentions) covers the picker.
Cover the four things every connection calc needs:
* **Geometry**: the members being joined, and the plate or weld arrangement if you have one in mind
* **Loads**: the factored forces the connection must carry
* **Materials**: member and plate grades, bolt grade and diameter, electrode
* **Code**: the standard, the edition, and LRFD or ASD
The calc sheet builds live in the [Canvas](/how-to/canvas) beside the chat: project reference, code references, each limit state checked with its spec section, and the final design status. The finished files arrive as download links; the deliverable side is covered in [Mathcad Calc Sheets](/workflows/mathcad-calc-sheets).
**Set your header fields first.** Project name, number, calc by, checked by, and your company logo carry onto every sheet. See [Branded Reports](/workflows/branded-reports).
One follow-up turns the draft into a plan:
```text The follow-up theme={null}
List every limit state you did not check for this connection,
and why each one could matter here.
```
Prying action, block shear on the coped beam, weld access: whatever comes back is your checklist for the next request.
Keep the thread going and reference what is already on the table: "Now design the base plate for the same column, using the reactions from the shear tab calc." One connection per request keeps every calc clean and checkable.
***
## More Briefs That Work
```text Base plate theme={null}
Design the base plate for an HSS8x8x1/2 canopy column:
120 kip factored axial, 15 kip factored shear. A36 plate on
4000 psi concrete, 3/4 in F1554 Grade 36 anchor rods.
AISC 360-22, LRFD. Cite the sections you use.
```
```text Weld check theme={null}
Check a fillet weld: E70XX electrode, 1/4 in leg, 10 in weld
length, 35 kip required shear. AISC 360-22 LRFD. Quote the
table you take the nominal weld stress from.
```
Both follow the same shape as the shear tab brief: geometry, loads, materials, code, and a request for citations.
You are the engineer of record: the agent checks the limit states and cites the sections, and you verify the calc line by line before it goes in the package.
***
## Next Steps
The sibling workflow for members: beams, columns, footings
[Design Checks](/workflows/design-checks)
The calc deliverable: formats, downloads, checking
[Mathcad Calc Sheets](/workflows/mathcad-calc-sheets)
Header fields and your logo on every sheet
[Branded Reports](/workflows/branded-reports)
The agent behind this workflow, end to end
[Structural Agent guide](/platform-guides/structural-agent)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Design Checks
Source: https://docs.stru.ai/workflows/design-checks
Brief the agent on geometry, loads, materials, code, and units, and get a complete beam, column, slab, or footing check as a downloadable calc package
## A Complete Brief Gets a Complete Deliverable
Describe the element the way you'd brief a junior engineer and the [Structural Agent](/platform-guides/structural-agent) returns a finished design check: every step shown, every clause cited, delivered as a [Mathcad calc sheet](/workflows/mathcad-calc-sheets), an [Excel workbook](/workflows/excel-spreadsheets), or a PDF. This page is about writing that brief; those two pages cover the deliverables.
A strong brief names five things:
| Give it | Example |
| ------------- | ------------------------------------------ |
| **Geometry** | W18x40, 28 ft span, braced at third points |
| **Loads** | 0.6 klf dead, 0.8 klf live, unfactored |
| **Materials** | ASTM A992, f'c 4000 psi, Grade 60 |
| **Code** | AISC 360-22 LRFD, ACI 318-19 |
| **Units** | US customary or metric |
Need the loads first? [Wind & Seismic Loads](/workflows/wind-seismic-loads) covers pulling the site design parameters. Put together, the five ingredients are the whole prompt:
```text Example: steel beam check theme={null}
Check a W18x40 floor beam for the Office Building Demo project.
ASTM A992. Span 28 ft, simply supported, braced at third points.
Loads: 0.6 klf dead, 0.8 klf live, unfactored.
Design per AISC 360-22 LRFD, US customary units.
Check flexure, shear, and live load deflection against L/360.
Quote the clause text for each provision you use.
Deliver as a Mathcad calc sheet.
```
**Ask it to quote the clause text.** Name the code edition and jurisdiction, then add "quote the clause text you used" to the brief. The citations come back with the code language on the sheet, ready for your checker. For code questions without a calc attached, see [Code Questions](/workflows/code-questions).
***
## Set the Code Family First
The design standard selector next to the agent name sets which code family the agent works from, and which code documents appear when you type **@** in the message box.
Pick the region there, then name the exact code and edition in the brief. Working in another jurisdiction or language? See [Local Codes & Languages](/workflows/local-codes-languages).
***
## One Element per Request
Ask for the beam, then the column, then the footing. Each check lands cleanly, and each one builds on the last: the beam reactions become the column loads, and the column loads size the footing.
Send the beam brief above. The calc sheet builds live in the [Canvas](/how-to/canvas) beside the chat while the agent works.
Before moving on, turn the draft into a plan:
```text theme={null}
List every limit state you did not check for this beam.
```
The answer (bearing at the supports, the unbraced construction case, vibration, whatever applies) is your worklist for the next request.
The conversation keeps the numbers, so the next brief leans on the last one:
```text theme={null}
Now check the supporting column: W10x49 trial, A992, 14 ft story
height, K = 1.0. Use the beam reactions from the check above plus
120 kip from the levels over it. Same code and units.
```
```text theme={null}
Size the spread footing for that column: allowable bearing 3 ksf,
f'c 4000 psi, Grade 60 bars, ACI 318-19. Check bearing, one way
shear, punching shear, and flexure, and give me the rebar callout.
```
Three requests, three clean calc sheets, one load path.
***
## Work From Your Drawings
Attach the sheet you are working from and reference it with **@**, so the agent takes the spans, sizes, and loads from your drawing instead of your memory.
```text Example theme={null}
@Office_Building_Demo_S2.1.pdf Check the typical infill beam on
grid line B, second floor. Take the size, span, and loading from
the plan and the general notes, and state what you read before
you calculate.
```
"State what you read" puts the agent's reading of the drawing on the record where you can confirm it before the math starts. Attachment and tagging mechanics are in [Using the Chat Input](/how-to/chat-input) and [Mentions & Attachments](/how-to/mentions).
***
## Briefs by Element
The steel brief above carries straight over to concrete and post tensioned members: geometry, loads, materials, code, units.
```text Example: post tensioned beam theme={null}
Check the post tensioned transfer beam on grid C: 24 in x 48 in,
f'c 6000 psi, twelve 0.5 in 270 ksi strands, 45 ft span.
Loads: 2.0 klf dead, 1.2 klf live, unfactored. ACI 318-19, US units.
Check service stresses at transfer and final, then ultimate
flexure and shear.
```
For the connections at each end of the beam, see [Connection Design](/workflows/connection-design).
Give the axial load and any moment, and ask for the interaction check:
```text Example: steel column theme={null}
Check a W10x49 column, A992, 14 ft story height, K = 1.0 both axes.
Pu = 250 kip with Mux = 40 kip ft from frame action.
AISC 360-22 LRFD, US units. Run the interaction check and quote
the clause behind the effective length you use.
```
Name the bay, the column, and the loads:
```text Example: two way slab theme={null}
Check the 8 in flat plate at a typical interior column: 20 ft x 22 ft
bays, 14 in square column, f'c 5000 psi. Superimposed dead 25 psf,
live 50 psf. ACI 318-19, US units. Check punching shear and one way
shear, and state the effective depth you assume.
```
An existing slab takes the same brief with the new load as the input: a crane outrigger or boomlift wheel load on an existing slab is a punching and flexure check with the pad size and load named. To weigh precast options against each other (hollow core plank against double tees), build the comparison as an [Excel workbook](/workflows/excel-spreadsheets).
Give the service loads and the allowable bearing:
```text Example: spread footing theme={null}
Size a spread footing for 250 kip dead plus live service load:
allowable bearing 3 ksf, f'c 4000 psi, Grade 60, ACI 318-19,
US units. Check bearing, one way shear, punching shear, and
flexure, and give me the rebar callout.
```
Retaining walls take the same brief with the soil as the load: retained height, backfill slope, soil unit weight and friction angle, surcharge. To pull the soil parameters out of a geotech report first, see [Geotech & Foundations](/workflows/geotech-foundations).
***
## Before It Goes in the Package
Have the agent read the numbers back. Ask it to walk you through the governing check in the finished file: the demand, the capacity, the clause, the margin.
```text Example theme={null}
Walk me through the governing check in this calc: what governs,
the demand and capacity numbers, and the clause each comes from.
```
You are the engineer of record, and the read back is how you put your confidence behind the sheet. Then send it out looking issued: set your header fields and firm logo once, and every calc arrives on your letterhead. See [Branded Reports](/workflows/branded-reports).
***
## Next Steps
Get the check as a downloadable .mcdx and PDF
[Mathcad Calc Sheets guide](/workflows/mathcad-calc-sheets)
Get the check as a workbook with live formulas
[Excel Spreadsheets guide](/workflows/excel-spreadsheets)
Header fields and your firm's logo on every sheet
[Branded Reports guide](/workflows/branded-reports)
Site design parameters to feed the brief
[Wind & Seismic Loads guide](/workflows/wind-seismic-loads)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Review Drawings, Submittals & Specs
Source: https://docs.stru.ai/workflows/document-review
Attach the documents and get a structured review in chat: submittals against design drawings, proposal comparisons, and spec discrepancies
## A Structured Review, in Chat
Attach the documents, say what each one is, and ask for the review. This is the conversational pattern for reviewing specific documents (a submittal, a spec section, two competing proposals, a Basis of Design) against each other or against your design documents, with findings you can act on.
It works across the disciplines a project throws at you: a fabricator's steel submittal against the structural drawings, an architectural door schedule against the spec, an MEP shop drawing against the design intent, a contractor's proposal against the tender documents.
**Three ways to review, one habit of checking.** This page is the chat review of documents you attach or tag. The [Review Agent](/platform-guides/review-agent) is for conversations across a whole ingested drawing set. A [Drawing Review](/how-to/drawing-review) is the formal, set-wide QA/QC run that produces a findings report. Start here for specific documents; move up when the question covers the whole set.
***
## How to Run One
Attach with the **+** button, or tag files already in your project with **@** ([Mentions guide](/how-to/mentions)). Then assign roles in plain language: *"The first file is the submittal; the other two are the design drawings it must match."* Before the review starts, ask the agent to list the files it can see, so the review runs on everything you sent.
Ask for a structured review and define the structure: each finding with its location in both documents, what differs, why it matters, and the suggested action. Name your code and jurisdiction, and ask the agent to quote the clause text behind any code-based finding, so every citation is ready for a reviewer to verify.
After the first pass: *"List everything you did not compare."* The answer tells you whether the review covered dimensions but not finishes, or details but not notes, and becomes the brief for the second pass.
Real discrepancies become RFIs ([Generate RFIs & RFAs](/how-to/generate-rfi-rfa)) or review comments. Ask for the findings as a comment log or comparison table when you need a file to circulate; name the format and the agent produces it.
The setup for a submittal review, ready to send: documents attached, roles assigned, finding format defined.
***
## Four Reviews Engineers Run
```text Example: submittal review theme={null}
@Steel_Stair_Submittal.pdf @S-501.pdf @S-502.pdf
The first file is the fabricator's submittal; the other two
are the design drawings. Compare member sizes, connection
details, materials, and finishes. For each discrepancy give
me: the submittal page, the drawing reference, what differs,
and whether it warrants a comment or an RFI.
```
```text Example: proposal comparison theme={null}
@PT_Proposal_A.pdf @PT_Proposal_B.pdf
Compare these two post-tensioning proposals side by side:
tendon quantities, anchorage details, assumed losses, scope
exclusions, and program. Give me a comparison table first,
then a recommendation with the reasons.
```
```text Example: Basis of Design review theme={null}
@Basis_of_Design.pdf
Read this as a design-risk reviewer. List the assumptions
that carry the most risk if they turn out wrong, the
requirements that conflict with each other, and anything
underspecified that will surface later as a change. Rank by
impact and cite the section for each.
```
```text Example: spec discrepancy check theme={null}
@Spec_Section_03_30_00.pdf @S-001_General_Notes.pdf
Find every point where the concrete spec section and the
structural general notes disagree: strengths, cover, testing,
curing. Cite the spec paragraph and the drawing note for each
one, and flag which document should govern.
```
**One comparison per request.** Submittal vs drawings is one review; spec vs drawings is another. Separate requests produce separate, traceable findings lists instead of one blended answer.
***
## When the Question Covers a Whole Set
For questions that span every sheet of a project ("where is this detail called out?", "does the callout on S-301 resolve?"), switch to the [Review Agent](/platform-guides/review-agent): it works inside a project folder, follows callouts and cross-references between sheets, and cites the sheet and detail behind each answer.
And when you want a formal record rather than a conversation, launch a [Drawing Review](/how-to/drawing-review): the set-wide QA/QC run that sweeps every sheet and delivers a findings report you can interrogate afterwards.
You are the engineer of record: the review surfaces the discrepancies, and the acceptance codes and dispositions stay yours to assign.
***
## Next Steps
Chat with a whole drawing set: callouts, details, findings.
The formal set-wide QA/QC run with a findings report.
Draft the RFI once a discrepancy is confirmed.
Tag documents already in your project with @.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Excel Spreadsheets
Source: https://docs.stru.ai/workflows/excel-spreadsheets
Build Excel design workbooks with live formulas, or hand the agent your existing spreadsheet to explain, check, and extend
## A Calc That Works Like a Tool
Ask the [Structural Agent](/platform-guides/structural-agent) for a spreadsheet and it builds a working **.xlsx**: inputs at the top, formulas live in the cells, checks that recalculate when a number changes. Download it once and it becomes a tool your team reuses on the next project.
Workbooks engineers build this way:
* **Design checkers**: a crane outrigger or boomlift wheel load on an existing slab, with the pad size and load as inputs
* **Option comparisons**: hollow core plank against double tees for the same bay, side by side
* **Load takedowns and schedules**: tributary areas in, column loads out
* **Extensions of the firm's own sheets**: hand over the workbook you already trust and grow it
***
## Step-by-Step
Name the inputs, the checks, the code, and the units, the same brief as any [design check](/workflows/design-checks):
```text Example: outrigger check workbook theme={null}
Build a workbook that checks crane outrigger loads on an existing
slab. Inputs: load per outrigger, pad size, slab thickness, f'c,
and reinforcement. Check punching shear and flexure per ACI 318-19,
US units, and flag any demand capacity ratio over 1.0.
```
The workbook opens as a live grid in the [Canvas](/how-to/canvas): sheet tabs along the bottom, cells that recalculate.
Click a cell and change a number for a quick what-if. For a change that should stick, tell the agent ("set the pad to 30 in square and update the checks") and it becomes part of the real workbook. The header rows at the top (project, calc by, checked by, design code) fill from the header fields you set once: see [Branded Reports](/workflows/branded-reports).
The workbook arrives as an .xlsx download link in the chat and is saved to your [Files area](/how-to/file-management) automatically, so you can tag it with **@** in every future conversation.
The formulas stay live, so every result traces back to its inputs. Trace the governing check before the workbook goes to the project team: you are the engineer of record, and a workbook you have traced is a workbook you can stand behind.
***
## Hand Over Your Existing Workbook
Tag the spreadsheet your firm already uses and put the agent to work on it:
```text Explain and audit theme={null}
@Wind_Pressure_Workbook.xlsx Walk me through this workbook: the
inputs, what it checks, and any formula that looks off.
```
```text Extend it theme={null}
@Wind_Pressure_Workbook.xlsx Add a components and cladding sheet
for the roof zones, same layout and conventions as the wall sheet.
```
The agent follows your layout and your conventions, so the new sheet reads like the rest of the workbook. Tagging mechanics are in [Mentions & Attachments](/how-to/mentions).
***
## Compare Design Options
A comparison is a workbook job: options in columns, criteria in rows, formulas doing the arguing.
```text Example: precast options theme={null}
Compare 8 in hollow core plank with a 2 in topping against 24 in
double tees for a 45 ft span parking level, 40 psf live load.
Build one comparison sheet: capacity, self weight, structural
depth, and camber side by side, with the governing criterion
flagged for each option.
```
**Same numbers, calc sheet format.** Have any workbook rebuilt as a Mathcad sheet, every formula written out with its code reference for line by line review: [Mathcad Calc Sheets](/workflows/mathcad-calc-sheets).
***
## Next Steps
How to write the brief that gets a complete calc
[Design Checks guide](/workflows/design-checks)
The same calcs as .mcdx sheets for line by line review
[Mathcad Calc Sheets guide](/workflows/mathcad-calc-sheets)
Header fields and your firm's logo on every deliverable
[Branded Reports guide](/workflows/branded-reports)
The live grid where your workbook takes shape
[Canvas guide](/how-to/canvas)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Foundations, Retaining Walls & Shoring
Source: https://docs.stru.ai/workflows/geotech-foundations
The design side of geotechnical work: footings, retaining walls, slope stability, and shoring or ERSS feasibility from your soil parameters
## The Design Side of the Ground
Give the agent the soil parameters and the design question, and it runs the geotechnical design work: footing sizing, retaining wall checks, slope stability, shoring and ERSS feasibility. Starting from a raw soil investigation report instead? [Soil Investigation & ERSS](/workflows/soil-investigation-erss) covers interpreting the report and building the ground model; this page picks up where the parameters are known.
Jobs this page covers:
* **Soldier pile wall feasibility** for an excavation next to something that must not move
* **Slope stability review** of a cut or fill against a target factor of safety
* **Crane ground bearing** over piles, and other temporary works checks
* **Footing design**, from bearing through punching shear
***
## Give the Ground Up Front
A geotechnical answer is only as good as the ground model behind it, so the brief carries everything: soil profile with parameters, groundwater, geometry, loads, code, and units. A complete brief gets a complete deliverable; anything you leave out, the agent has to assume, and the assumptions are what you end up re-checking.
```text Example: soldier pile feasibility brief theme={null}
Soldier pile wall feasibility for a 7.5 m deep excavation.
Soil profile (from the SI report):
- 0 to 3 m: loose sandy fill, phi 28 deg, gamma 18 kN/m3
- 3 to 9 m: firm marine clay, cu 35 kPa, gamma 16 kN/m3
- below 9 m: dense cemented sand, SPT N over 50
Groundwater at 2.0 m depth. Surcharge 10 kPa; a road runs 4 m
from the excavation face. Code: Eurocode 7. Units: kN, m.
Give me: required embedment, an indicative pile section and
spacing, the maximum bending moment, and whether one row of
struts or anchors is needed. State every assumption, and quote
the clause text behind any code limit you apply.
```
Naming the code and asking for quoted clause text does double duty: the citations arrive reviewer-ready, and you see exactly which provision each limit came from.
In the app, the brief goes in as one message:
**The constraints drive the concept.** Adjacent structures, groundwater, headroom, and sequencing shape a shoring or foundation scheme more than the soil parameters do. Put them in the brief.
***
## One Element Per Request
Work the scheme element by element, the way you would assign it: the wall, then the struts and walers, then base stability, then the settlement check on the neighbor. Each request gets a focused answer you can verify before the next element builds on it. For a foundation package: the footing, then the pedestal, then the anchorage.
```text Example: the follow-up chain theme={null}
Take the soldier pile option forward. First: the pile section
check at the maximum moment, with the governing combination shown.
We will do the walers and struts next, then base heave.
```
***
## Worked Examples
### Slope stability review
```text Example: slope stability theme={null}
Review the stability of a 1V:2H cut slope, 6 m high, in the soil
profile above. Groundwater at 2.0 m. Target factor of safety 1.4
for the temporary condition. Which failure surface governs, what
factor of safety do you get, and what changes if groundwater
rises by 1 m? Show the method and every assumption.
```
The groundwater sensitivity question is the useful one: it tells you whether the slope is comfortable or one wet week from the limit.
### Crane ground bearing on bored piles
```text Example: crane ground bearing theme={null}
A 250 t crawler crane tracks across a piled slab area. Track
pressure from the lift plan: 180 kPa over 1.2 m x 6.5 m per
track. The slab is 400 mm thick and spans to 900 mm diameter
bored piles on a 6 m grid, pile working load 3,200 kN. Check
ground bearing under the tracks and the load shed to the piles
for the worst track position. Code: Eurocode 7. State the
assumptions and quote the clause text for any factor you apply.
```
Attach the lift plan and reference it with **@** so the agent takes the track loads and positions from your document, not from typical values: [Mentions guide](/how-to/mentions).
### Footing design
Footings follow the member-check pattern end to end: bearing, sliding, overturning, then structural design of the pad. [Design Checks](/workflows/design-checks) covers it in full; the geotechnical half of the brief looks like this:
```text Example: footing brief theme={null}
Design an isolated pad footing for a column load of 1,800 kN dead
plus 950 kN live. Allowable bearing 150 kPa at 1.5 m depth,
groundwater below 5 m. Concrete C32/40. Code: Eurocode 2 and
Eurocode 7. Start with the plan size and bearing check only; we
will do punching shear next.
```
***
## Close Out the Design
Before the scheme leaves the conversation:
* **Ask what was not checked.** *"List every failure mode you did not check"* turns the draft into a plan: global stability, hydraulic heave, wall deflection, settlement of the neighbor, whatever the first pass left out.
* **Have it read the governing check back.** *"Walk me through the governing check: the numbers, the clause, and the margin."* A check you can hear explained is a check you can defend.
* **Produce the deliverable.** Ask for the calc as a Mathcad sheet ([Calc Sheets in Mathcad](/workflows/mathcad-calc-sheets)) or a formatted report on your firm's letterhead with your header fields and logo ([Branded Reports](/workflows/branded-reports), with the logo pulled from your [Standards folder](/how-to/standards-folder)).
You are the engineer of record: the concepts and checks here are a strong first pass, and the judgment that turns them into a design is yours.
***
## Next Steps
Interpret the SI report and build the ground model first.
Beams, columns, and footings: the member-check pattern.
Turn the geotechnical check into a formatted calc sheet.
Deliverables on your firm's letterhead, logo and all.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Local Codes & Languages
Source: https://docs.stru.ai/workflows/local-codes-languages
Chat in Vietnamese, Spanish, German, or Persian, name your jurisdiction and code edition, and get answers and deliverables in your language
## Work in Your Language
Write to the agent in the language your project runs in, and it answers in kind: the reasoning, the citations, and the follow-up questions all come back in your language. Stru AI is an ecosystem of AI agents for Architectural, Civil, and Engineering work, and that work happens in Vietnamese, Spanish, German, Persian, and English alike.
The prompt pattern does not change. Name your jurisdiction and your code edition, give the inputs up front, and ask for the clause quotes. Only the language does.
***
## Ask in Your Language
The same strong brief, from three different desks:
```text theme={null}
Diseña una zapata aislada para una columna de 400 x 400 mm
con carga axial mayorada de 900 kN, concreto de 28 MPa,
según ACI 318-19. Cita las secciones que uses.
```
```text theme={null}
Prüfe einen Einfeldträger IPE 300, Spannweite 6 m,
Streckenlast 12 kN/m, Stahl S235, nach Eurocode 3.
Zitiere die verwendeten Abschnitte.
```
```text theme={null}
Tính tải trọng gió cho tòa nhà văn phòng 10 tầng tại
TP. Hồ Chí Minh theo TCVN 2737. Trích dẫn điều khoản
đã dùng.
```
Ask in Spanish and the whole answer comes back in Spanish, citations included:
**Switch languages when the audience changes.** In the same thread, ask for the answer again in English for a colleague or a reviewer, and the agent restates it, citations intact.
***
## Find Your Region's Codes
Two controls point the agent at the codes that govern your project:
The selector next to the agent name at the top left sets which family of codes the agent works from.
Type **@** in the message box. The green **Standards** section lists the design codes available for your selected standard: that in-app list is the source of truth for your region. The [Mentions guide](/how-to/mentions) covers browsing and searching it.
State the city or authority having jurisdiction and the code edition you are designing to, in whatever language you are writing. The citations come back against the edition you named, ready to verify, the same habit that drives [Code Questions](/workflows/code-questions).
***
## Deliverables in Your Language
Calc packages, reports, and spreadsheets come out in the language you ask in, so you check the memoria de cálculo in Spanish and issue it in Spanish:
```text Ejemplo theme={null}
Entrega la memoria de cálculo en español, en formato PDF,
con el membrete de la empresa.
```
With your logo and header fields set up once, the deliverable lands on your firm's letterhead in your language. See [Branded Reports](/workflows/branded-reports) for the setup.
You are the engineer of record in every language: the citations come back quotable so you can verify them against the code text you hold.
***
## Next Steps
Reviewer-ready answers with the clause text quoted
[Code Questions](/workflows/code-questions)
The @ picker: standards, files, and folders
[Mentions guide](/how-to/mentions)
Your letterhead on every deliverable
[Branded Reports](/workflows/branded-reports)
The generalist agent, end to end
[Structural Agent guide](/platform-guides/structural-agent)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Mathcad Calc Sheets
Source: https://docs.stru.ai/workflows/mathcad-calc-sheets
Ask for a calc and download a formatted, unit aware Mathcad sheet, built live in the Canvas with a PDF report alongside
## From Prompt to .mcdx
Ask the [Structural Agent](/platform-guides/structural-agent) for a calc as a Mathcad sheet and the finished file comes back as a **.mcdx** download with a PDF report alongside: header, assumptions, code references, the calculations, and the final design check, laid out to be reviewed line by line.
The whole workflow fits in one exchange:
Calc packages engineers pull this way: wind pressure packages, retaining wall design calcs, post tensioned beam checks, weld and connection checks, and the firm's old Excel sheets rebuilt as Mathcad.
***
## Step-by-Step
Give the brief in one message (geometry, loads, materials, code, units) and end with "deliver as a Mathcad calc sheet". [Design Checks](/workflows/design-checks) covers the brief in depth; here is one for a full package:
```text Example: wind pressure package theme={null}
Create a wind pressure calc package for a 45 ft tall office
building at 1600 4th Ave, Seattle, WA 98101. ASCE 7-22, Risk
Category II, Exposure C. MWFRS pressures for both directions
and components and cladding zones. US units.
Deliver as a Mathcad calc sheet.
```
Need the site parameters first? See [Wind & Seismic Loads](/workflows/wind-seismic-loads).
The sheet takes shape in the [Canvas](/how-to/canvas) beside the chat: header first, then assumptions, code references, calculations, and the design check.
Click anywhere on the sheet to place a cursor. The agent sees where you are pointing, so "add the parapet case here" needs no further explanation.
Follow-ups edit the same sheet: "tighten the deflection check", "add the roof uplift case", "switch the exposure to D and update everything downstream". Keep each request to one change and the sheet stays clean.
The finished files arrive as download links in the chat: the .mcdx, a PDF report, and the supporting files, all saved to your [Files area](/how-to/file-management) automatically.
***
## Rebuild an Excel Sheet as Mathcad
Firms keep years of design spreadsheets. Tag one and have it rebuilt as a calc sheet with the math written out:
```text Example theme={null}
@Base_Plate_Design.xlsx Rebuild this spreadsheet as a Mathcad calc
sheet: same inputs, same checks, every formula written out with
its code reference so it can be reviewed line by line.
```
The agent reads the workbook, traces the formulas, and lays the calc out as a sheet a checker can follow without opening Excel. Tagging is covered in [Mentions & Attachments](/how-to/mentions); the reverse direction (a calc as a living workbook) is [Excel Spreadsheets](/workflows/excel-spreadsheets).
***
## Read It Back Before You Sign
The last step of a strong session is a walkthrough. Ask the agent to read the finished sheet back:
```text Example theme={null}
Open the finished calc and walk me through the governing check:
the demand, the capacity, the clause it comes from, and the margin.
```
You are the engineer of record, and the walkthrough is how you put your confidence behind the numbers before the package goes out.
***
## On Your Firm's Letterhead
Every sheet carries a project header you control: project name, number, task, calc by, checked by, dates, address, and your company logo from the [Standards folder](/how-to/standards-folder). Set the fields once and the .mcdx and the PDF both come out looking issued. The setup is [Branded Reports](/workflows/branded-reports).
***
## Next Steps
How to write the brief that gets a complete calc
[Design Checks guide](/workflows/design-checks)
Header fields and your firm's logo on every sheet
[Branded Reports guide](/workflows/branded-reports)
The same calcs as workbooks with live formulas
[Excel Spreadsheets guide](/workflows/excel-spreadsheets)
The workspace where the sheet takes shape
[Canvas guide](/how-to/canvas)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Meeting Minutes & Action Trackers
Source: https://docs.stru.ai/workflows/meeting-minutes
Turn raw meeting notes or a transcript into formatted minutes and an action item tracker
## Notes In, Minutes Out
Give the [Structural Agent](/platform-guides/structural-agent) your raw material (typed notes, a transcript export, photos of a marked-up agenda) and ask for minutes. It structures the discussion into topics, decisions, and action items, and formats the result as a document you can circulate.
## Step-by-Step
Attach the source with the **+** button in the message box, or paste text straight in. Transcript exports from your meeting software (Word, PDF, or plain text) work as attachments. Photos of handwritten notes work too.
Name the project, the meeting, and the attendees. Ask for the outputs you need:
```text Example theme={null}
@OAC_Meeting_Transcript.docx Draft meeting minutes for the
Building 4 OAC meeting, June 12. Attendees: J. Doe (owner rep),
A. Smith (architect), our office (SEOR). Organize by topic,
capture decisions and open items separately, and end with an
action item table: item, owner, due date.
```
The agent returns the minutes in the conversation. Correct anything it misheard or misattributed with a follow-up message:
```text theme={null}
The waterproofing decision was tabled, not approved. Move it
to open items and assign it to the architect.
```
Ask for the format you circulate: Word, PDF, or both. For the action tracker, ask for a spreadsheet:
```text theme={null}
Finalize as a PDF, and give me the action item table as an
Excel file I can update between meetings.
```
The files arrive as download links and are saved to your [Files area](/how-to/file-management).
**Company minutes format?** Keep your minutes template in your [Standards folder](/how-to/standards-folder) and the agent follows it automatically. See [Branded Reports](/workflows/branded-reports) for the setup.
## Keeping the Tracker Alive
Bring the tracker back to the next meeting's notes and ask the agent to reconcile:
```text theme={null}
@Action_Tracker.xlsx @June26_Notes.txt Update the tracker from
these notes: mark completed items, add new ones, and flag
anything past due.
```
**Check attributions before circulating.** Minutes assign statements and commitments to named people. Read the draft against your own memory of the meeting; a misattributed decision causes more trouble than a missed one.
## Next Steps
Attaching files, dictating, and pasting.
Minutes on your company template.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Quantity Takeoff
Source: https://docs.stru.ai/workflows/quantity-takeoff
Pull quantities out of a drawing set or a BIM model: concrete volumes, steel tonnage, rebar schedules, with a scope brief that gets you numbers you can check
## Two Ways to Run a Takeoff
Stru produces quantity schedules from your drawings or your model. You define the scope, it does the measuring and tabulating, and you verify the result the way you'd check any estimator's work.
There are two ways to run a takeoff, depending on what you have:
Run a [Drawing Review](/how-to/drawing-review) in **Quantity Takeoff** mode. It reads the sheets and schedules like an estimator would
Ask the [BIM Agent](/platform-guides/bim-agent). It measures the model's actual elements and can price against a rate book
***
## Takeoff from a Drawing Set
One drawing set per folder: the takeoff covers what's in the folder. Include the schedules and any specs the quantities depend on. Folder setup is covered in [File Management](/how-to/file-management).
Right-click the folder's row and choose **Enable Reviews**, then click **Launch Review**. The full walkthrough is in the [Drawing Review guide](/how-to/drawing-review).
In the review dialog, choose the **Quantity Takeoff** mode card. This mode requires instructions: the brief decides what you get back.
Tell it exactly what to measure, in what units, with what rules, the way you'd brief a junior doing the takeoff by hand:
```text theme={null}
Produce a takeoff of all cast-in-place concrete by element type
(footings, walls, columns, slabs) in cubic yards, per level.
Deduct openings larger than 2 sq ft. Rebar tonnage per level
from the schedules. Present as one table per element type.
```
A good brief covers:
* **What to quantify**: elements, systems, or materials
* **Units**: cubic yards, tons, square feet, each
* **Deduction rules**: what openings or voids to subtract, and the threshold
* **Grouping**: per level, per element type, per sheet
Takeoffs are priced like any review: per drawing page in scope, shown before you start ([Review Pricing](/how-to/review-pricing)). Results land in the folder's **Reviews** section, with an email when done.
Spot-check the output the way you'd check a junior's takeoff: a few representative quantities measured by hand, the deduction rules honored, the schedule totals cross-footed. Use the [Review Agent](/platform-guides/review-agent) to interrogate any number: *"where did the level 3 slab volume come from?"*
**A takeoff is only as good as its scope brief.** "Take off the concrete" produces something generic; the brief above produces something you can check. Say what to measure, the units, and the deduction rules, every time.
***
## Takeoff from a BIM Model
Have an IFC model instead of (or alongside) the sheets? The [BIM Agent](/platform-guides/bim-agent) measures the model itself:
Pick **BIM Agent** in the agent dropdown, select the project folder holding the model, and attach or @-mention the `.ifc` file ([Mentions & Attachments](/how-to/mentions)).
```text theme={null}
Run a quantity takeoff on this model: concrete volume by element
type per level, structural steel tonnage by section size, and
formwork contact area. Flag any quantity that comes from a
bounding-box estimate rather than exact geometry.
```
The agent returns quantity tables in chat and can export them as a spreadsheet, and it tells you which quantities are exact and which are geometric estimates, so you know where to look closer.
**Drawings and a model?** Run both and compare: a drawing-based takeoff and a model-based takeoff that agree are worth far more than either alone.
***
## Next Steps
The full launch-to-results walkthrough
[Drawing Review guide](/how-to/drawing-review)
What each mode does, and how to brief it
[Review Modes & Instructions](/how-to/review-modes)
Model inspection, takeoffs, and costing
[BIM Agent guide](/platform-guides/bim-agent)
Per-page pricing, shown before you start
[Review Pricing guide](/how-to/review-pricing)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Rebar Drawing Review
Source: https://docs.stru.ai/workflows/rebar-drawing-review
Review reinforcement drawings for inconsistencies, omissions, congestion, and code issues before the bars are bent
## Catch It Before the Bars Are Bent
Reinforcement drawings fail in predictable ways: a splice length that contradicts the schedule, a bar mark on the plan that isn't in the schedule, a beam-column joint drawn with more steel than will physically fit. Each one is cheap to fix on paper and expensive to fix on site.
This workflow runs a [Drawing Review](/how-to/drawing-review) focused on the reinforcement, then uses the [Review Agent](/platform-guides/review-agent) to pressure-test what it finds.
What it catches:
* **Schedule vs. plan mismatches**: bar marks, sizes, and counts that don't agree between the schedule and the sheets
* **Development and splice length issues**: lengths on the details that look short against the schedule or the governing code
* **Congestion**: joints and connections where the drawn reinforcement won't place or consolidate
* **Omissions**: missing bar marks, details that reference nothing, zones with no reinforcement called out
***
## Step-by-Step
Put the reinforcement drawings, the general notes sheet, and the bar schedules in one [project folder](/how-to/file-management), plus the specs if splice/development requirements live there. The review reads the whole folder as one package.
Right-click the folder's row, choose **Enable Reviews**, check the file labels, then click **Launch Review**. The mechanics are in the [Drawing Review guide](/how-to/drawing-review).
* **Code Compliance**: when the question is *"do these details hold up against the code?"* (development lengths, cover, seismic detailing)
* **Consistency & Specs**: when the question is *"do the schedule, the plans, and the details agree with each other?"*
Either way, the instructions carry the rebar focus; see the briefs below. ([All six modes explained](/how-to/review-modes).)
Pick the brief that matches your worry, or combine them:
```text theme={null}
Check against ACI 318-19. Focus on reinforcement development
and splice lengths: flag every detail where the shown length
looks short against the schedule or the code. Include the
sheet, the detail, and the bar mark in each finding.
```
```text theme={null}
Review the beam-column joints and wall boundary elements for
reinforcement congestion: flag joints where the drawn bars,
ties, and embedded items look unplaceable or would block
concrete consolidation. This is SDC D, expect heavy
confinement steel.
```
```text theme={null}
Cross-check every bar mark on the plans and details against
the bar schedules: flag marks that appear on sheets but not
in a schedule (and the reverse), and any size or spacing
that disagrees between plan, detail, and schedule.
```
**Name the code edition.** *"Check against ACI 318-19"* beats letting the reviewer infer it. It is the single biggest upgrade to finding quality.
Confirm the price and start ([pricing is per drawing page](/how-to/review-pricing)). When results land in the folder's **Reviews** section, open the set with the [Review Agent](/platform-guides/review-agent) and pressure-test anything that matters:
```text theme={null}
Finding 12 says the splice at detail 4/S-502 is short. Walk me
through it: what length is shown, what does the schedule say,
and what does ACI require for a #8 top bar here?
```
**You're still the engineer of record.** The review flags candidates; the engineering call on every one of them is yours. Verify findings against the drawings and the code before anything gets revised. That is exactly what the Review Agent follow-up step is for.
***
## Next Steps
The full launch-to-results walkthrough
[Drawing Review guide](/how-to/drawing-review)
What each mode catches, with example briefs
[Review Modes & Instructions](/how-to/review-modes)
Chat with your drawings and findings
[Review Agent guide](/platform-guides/review-agent)
Editor access is needed to launch reviews
[Sharing & Permissions guide](/how-to/file-access)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Soil Investigation & ERSS Concepts
Source: https://docs.stru.ai/workflows/soil-investigation-erss
Interpret SI reports and borelogs, then develop preliminary earth retaining and stabilizing structure concepts
## From Borelog to Design Parameters
Attach a soil investigation report and the [Structural Agent](/platform-guides/structural-agent) reads it the way you would: soil strata, SPT N-values, groundwater, lab results. Ask for the interpretation you need, from a summary table of design parameters to a preliminary ERSS (earth retaining and stabilizing structure) concept to take into scheme design.
**Preliminary means preliminary.** The agent's interpretation and concepts are a starting point for the geotechnical and structural engineers of record, not a substitute for them. Verify parameters against the source report before any design rests on them.
## Interpret the SI Report
Attach the SI report with the **+** button, or tag it with **@** if it is already in your [Files area](/how-to/file-management). Multi-hundred-page reports are fine; tell the agent which boreholes matter if you know.
```text Example: parameter summary theme={null}
@SI_Report.pdf Summarize the soil profile at boreholes BH-3
through BH-6: strata, SPT N-values, unit weights, undrained
shear strengths, and groundwater levels. Present as a table
I can use for retaining wall design.
```
```text Example: specific questions theme={null}
@SI_Report.pdf What does the report recommend for excavation
support? Is there a soft clay layer below the proposed
formation level, and how thick is it?
```
The agent reports what the document says and where it says it. Spot-check the values against the borelogs before they go into a calc.
## Develop a Preliminary ERSS Concept
With the ground model established, describe the excavation and your constraints:
```text Example theme={null}
Using the soil profile from BH-3 to BH-6, propose preliminary
ERSS options for a 9 m deep excavation, 40 m x 25 m in plan.
Constraints: an existing building 6 m from the north face,
groundwater at 2.5 m depth. Compare a strutted sheet pile wall
against a bored pile wall: indicative wall depth, strut levels,
and the main risks of each. State every assumption.
```
The agent lays out the options with its assumptions stated, so each one can be checked and taken forward or discarded. Ask for the comparison as a table or a short report ([in your company's format](/workflows/branded-reports), if your templates are set up).
Follow-ups sharpen the concept:
```text theme={null}
Take the strutted sheet pile option: what wall embedment does a
first-pass stability check suggest, and which soil layer governs?
Show the calculation and the assumptions.
```
**Give the constraints, get a better concept.** Adjacent structures, groundwater, headroom limits, and sequencing drive ERSS selection more than the soil does. Name them in the prompt.
## Temporary Works Checks
The same pattern covers temporary works: attach the drawings or the contractor's submission and ask for a first-pass check.
```text theme={null}
@Shoring_Submission.pdf Check the strut and waler sizing against
the loads shown. Flag anything that looks under-designed and
list what information is missing for a proper check.
```
## Next Steps
The agent doing the reading and the calcs.
Tag reports already in your Files with @.
Turn the concept into a formatted deliverable.
Keep each project's SI data in its own folder.
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).
# Wind & Seismic Loads
Source: https://docs.stru.ai/workflows/wind-seismic-loads
Give a project address, risk category, and exposure, and get the site's wind, seismic, and snow design parameters with references, then a load calc package built from them
## From Address to Load Package
Give the agent the project address, the risk category, and the exposure, and it looks up the site's wind, seismic, and snow design parameters and returns them with the governing references. From there, ask for the load calc package and the parameters flow straight into it.
Any project that needs site hazard data starts the same way: an office building, a water treatment structure, a pedestrian bridge, a telecom mast. The brief is what makes it work, so give the inputs up front:
```text The site brief theme={null}
Get the wind, seismic, and snow design parameters for
2200 Harbor Ave, Portland, OR 97201 (Office Building Demo).
Risk Category II, Exposure C, Site Class D, per ASCE 7-22.
List every parameter with the section, table, or hazard map
it comes from.
```
Address, risk category, exposure, site class, and code edition: a complete brief gets a complete deliverable.
***
## Step-by-Step
The agent returns the design parameters for the location: wind speed, seismic ground motion values, snow load, each tagged with the reference it comes from.
Every parameter should trace to a section, table, or hazard map. For any value you will cite in a submittal, ask the agent to quote the source text, the same habit that makes [code questions](/workflows/code-questions) reviewer-ready.
One load type per request lands cleanly: the wind package first, then seismic, then snow, each building on the parameters already on the table.
```text The wind package theme={null}
Using those parameters, build the wind load calc for the
MWFRS: design pressures for each wall and roof zone, with
the equations and coefficients shown. Deliver it as a calc
package I can check line by line.
```
The deliverable side of this (formats, downloads, checking the sheet) is covered in [Mathcad Calc Sheets](/workflows/mathcad-calc-sheets).
**Put it on your letterhead.** Set the project name, number, calc by, checked by, and your company logo once, and every package comes out branded. See [Branded Reports](/workflows/branded-reports).
Before the package leaves your desk, ask the agent to walk you through the governing value in the finished file:
```text The read-back theme={null}
Walk me through the governing wind pressure in the finished
file: which zone, which equation, and which coefficients
produced it.
```
A number you have heard explained is a number you can defend.
***
## Where the Loads Go Next
The parameters and pressures feed directly into the rest of the design:
* **Element checks**: carry the loads into beam, column, and footing checks. See [Design Checks](/workflows/design-checks).
* **Analysis models**: apply them as load cases in an ETABS or SAP2000 model. See [Build ETABS & SAP Models](/workflows/build-etabs-sap-models).
You are the engineer of record: verify the parameters against the governing hazard data for the site before they drive a design.
***
## Next Steps
The calc package deliverable: formats, downloads, checking
[Mathcad Calc Sheets](/workflows/mathcad-calc-sheets)
Carry the loads into element design checks
[Design Checks](/workflows/design-checks)
Apply the loads as cases in an analysis model
[Build ETABS & SAP Models](/workflows/build-etabs-sap-models)
Header fields and your logo on every deliverable
[Branded Reports](/workflows/branded-reports)
**Questions?** Email **[support@stru.ai](mailto:support@stru.ai)** or [book a call](https://cal.com/priyankg/30-min-meeting).