| theme | default | ||||||
|---|---|---|---|---|---|---|---|
| highlighter | shiki | ||||||
| fonts |
|
||||||
| title | Creating Robust Agentic AI Systems to Increase Data Insight Accessibility | ||||||
| info | **Creating Robust Agentic AI Systems to Increase Data Insight Accessibility** *Also known as: Building Agentic Solutions for Construction* Analytics leaders are pushing **data-driven decisions** across the enterprise—for AEC that still means **field, trailer, and finance** working off the same facts. **Accessibility of insight** (not only raw tables) is the bottleneck; **agents and generative surfaces** help when outputs stay **accurate, grounded, and governable**. Robust agentic systems and accessible data insight for AEC. | ||||||
| class | text-left | ||||||
| transition | fade-out | ||||||
| mdc | true | ||||||
| duration | 120min |
Also known as: Building Agentic Solutions for Construction
HPC foundation (~10 years): shipping software products, taking them to market, and learning hyperscale reliability—customers across manufacturing, life sciences, oil & gas, aerospace, defense, and automotive. That shaped how I think about scalable systems.
Cloud shift: as HPC workloads moved cloudward, the work became architecting cloud-native applications and native integrations—the same discipline, different substrate.
FlyPaper (CTO): BIM coordination, superintendent dailies, and pull planning software grounded in the Last Planner System—mobile and web products built to meet crews in the field.
Procore acquisition → Barton Malow: helped stand up data and automation, built the engineering team, ran early “what is AI / how do we use it?” research, shipped internal orchestration work, and moved with the industry toward MCP-style tool contracts.
Today: building agentic AI solutions for AEC strategy professionals—with a special focus on competitive intelligence tools that empower BD and strategic decision-makers, as well as on enhancing preconstruction workflows for greater efficiency and insight.
In 2026 the battleground is who controls context and workflow—not which foundation model “wins.”
Strategy: choose off-the-shelf when the problem already fits the vendor’s graph and speed beats differentiation. Choose hands-on when workflow, data, economics, or deep internal business knowledge must be yours—or you share the same packaged intelligence as everyone else.
LLM = engine · orchestration = transmission
- Databricks Agent Bricks + Unity Catalog — agents, tools, and lakehouse data in one governed loop (identity, MCP catalog, observability)
- Procore Helix (Assist, Agent Builder, Datagrid / connectors)—excellent in-platform loop; weak where edge lives in local LOB spreadsheets / systems outside the graph
- Glean, Bedrock Agents — “managed factory”: you land data; they run the thinking loop (COIs, standard retrieval)
- Autodesk Assistant, Claude Cowork, Zapier-class hubs — utility productivity; vendor tax / metering for speed—fine when the vendor boundary is acceptable
- Workflow you encode — treat logic as a state machine, not a wall of prompt. Example: submittal — spec → extract → compare → if deviation > threshold → human. Stack: LangGraph / LangChain, AWS Agent Core, Temporal + n8n/Windmill for durable glue
- Typed + multi-agent — Pydantic AI (ERP-safe I/O), CrewAI (roles and handoffs)
- Integration boundary — custom MCP (Python/Node) for wholesale APS / Procore APIs vs throttled vendor MCP; connect internal + third-party systems and lake/warehouse views so stakeholders can ask data without living in SQL—full story on the MCP slide
- Product surface — Vercel AI SDK + bespoke UI (e.g. superintendent: Check safety · Summarize daily · Order materials)—tools, not a thread. Heatmap / silent auditor patterns — next slide
- Capacity under load — e.g. Bedrock provisioned throughput when crunch beats public rate limits (inference slide)
Role-appropriate surfaces — not “chat bad,” but “chat is one option”
Conversational analytics: when the surface is chat, context and specificity (what project, what time range, which source of truth) directly shape output quality—brief users once; don’t assume “the AI knows.”
Field vs. trailer: voice-forward chat can fit hands-busy field roles; a project engineer on an iPad or laptop in the trailer often needs structured views, approvals, and diff—not a thread.
When chat is the wrong default: if the job is “produce an artifact” (report, package, leveled bid), ship the artifact UI—a dashboard or wizard that thinks, instead of making people type prompts.
Not only a chatbot that “explains BLS.” Ship an interactive labor study—BLS (and peers) fused with your assumptions, AI synthesis, exportable narrative—so users manipulate the report, not the prompt box.
Example — submittal reviewer: drag a PDF; get side-by-side redline and citations—not a chat transcript.
MCP is one way to wire tools — the business question is who owns the boundary
Vendor path: Procore / Autodesk / others ship agents, connectors, and “opinionated” flows—fast to adopt, often metered, roadmap is theirs. You pay for the abstraction; it may not optimize for your margin.
Build path: Custom integrations (including MCP servers) across internal systems and third-party platforms—APS, ERP read models, lake / warehouse views—your auth, caching, pagination, and policy. Sometimes you can beat packaged assistants on latency and unit economics—sometimes not; prototype both.
Decision lens: technical capability and strategic fit; integration surface area (how many systems?), compliance, rate limits, and whether the vendor’s “happy path” matches your WBS / CM reality.
Own the boundary you cannot afford to rent: lineage, approvals, and where context is assembled.
Where you run matters as much as which model
flowchart LR
subgraph paths [Call paths]
D[Direct vendor API]
H[Hyperscaler hosted Anthropic OpenAI Google]
end
D --> T[Tokens billed per call]
H --> T
T --> K[Demand spikes caching regional residency]
Prototype vs. production: direct Anthropic / OpenAI APIs for benching; Bedrock / Azure OpenAI / Vertex for procurement, guardrails, and data residency.
Economics move: Anthropic models run on AWS—list vs. Bedrock pricing crosses over over time as deals change. Re-benchmark quarterly; the “cheaper path” is not a constant.
Tokens = capacity planning: batch size, concurrency, prompt caching for stable corpora (spec books), and back-pressure when vendors throttle.
Security story: keep payloads in your boundary; enterprise agreements for training use—give IT one crisp sentence.
Models are stochastic—reliable systems come from router / worker / judge, schemas, and eval loops, not from pretending the LLM is a calculator.
flowchart TB
R[Router small 8B-class] --> W[Worker 70B-class or API]
W --> J[Judge frontier when risk is legal or contractual]
W --> L[Local or HF endpoint for repetitive extract]
Use the smallest reliable model per step — tokens are margin, and latency is trust.
Hugging Face & self-host: great for exploration, air-gapped constraints, and high-volume narrow tasks—know your ops cost, not just API list price.
Anti-pattern: “Claude for everything” is using a haul truck to catch a mouse—fun demos, expensive production.
flowchart TB
A[Instruction-tuned prompts 5 to 10 gold examples] --> B[Max context plus caching]
B --> C{Need FT?}
C -->|Usually no| D[Ship evaluate iterate]
C -->|Sometimes| E[Strict JSON contract or 1M plus tiny tasks daily]
Before fine-tuning, exhaust: ICL + full context (manuals, standards packs) with caching where available.
Fine-tune when: you need a hard format contract or massive repetitive micro-tasks where latency/cost dominates.
Trust before weights: guardrails, structured outputs, and eval + reasoning loops with human gates—instruction and ICL usually move accuracy more than fine-tune; don’t erode stakeholder confidence chasing novelty.
Motto: context windows first; weights are a secondary lever.
Problem Reviewers miss alternates buried in long vendor PDFs.
Task Agentic flow that flags mismatches against the master spec — without a chat-first UI.
Problem Twenty trade bids with different exclusions and scopes.
Task Use MCP to pull APS model or property data and normalize bids into a standard WBS view.
More workshop ideas — swap in for a future session or spare group
Problem Draws, pay apps, and vendor invoices drift from contract / SOV language—finance catches it late.
Task Agentic line-item reconciliation (invoice ↔ contract ↔ change orders) with an exceptions queue and citations—not a chat thread.
Problem Exports are noisy: duplicate vendors, bad codes, inconsistent units—BI is downstream of garbage.
Task AI-assisted normalization (suggest mappings, cluster dupes) with human approval gates; ship clean dimensions to the warehouse.
After groups present — use this to score designs in ~2 minutes each. Favor ideas with a clear pilot metric (time saved, defect rate, adoption) so spend stays justified.
- Architecture: router/worker/judge — or one monolithic call?
- UX: chatbot by default, or a tailored surface?
- Data: what is the source of truth and who can access it?
- Monday plan: what is the 30-day pilot (scope, metrics, owner)?
- Outcome: what measurable result unlocks the next funding or scale gate?
Your job is not to be an AI user. It is to be a practitioner: build bridges, own context, and protect your company’s intelligence.
Data insight accessibility · AEC · Own the graph
https://www.linkedin.com/in/ispyhumanfly/ or email me at dan@thoughtpivot.com.