Sprint 1 · Open cohort

Agentic AI for Structural Engineers

Hour one, an AI designs a building in front of you. Hour twelve, you command it — and architect your own.

A 12-hour live sprint that takes you from AI user to agentic architect — how LLMs really work, how to make your expertise persistent, how agents act through tools, and how to architect AI workflows you can defend. Taught in the language you already speak: structures, with In-Structure AI as your laboratory, free for every enrolled engineer.

12 h

4 live sessions × 3 h

10

engineers per cohort

100%

virtual · live · hands-on

$0

software cost · platform included

4

interactive learning artifacts

6

verified learning outcomes

Juan David Gómez

Academic coordinator · engineering professor · PhD in computational mechanics · 20+ years of structural practice and teaching

Who this is for

Civil engineers and students, new to AI

This sprint is designed for civil engineers — from students finishing their degree to senior practitioners — who want to move beyond casual AI usage toward structured, professional AI practice. Whatever engineering judgment you bring is not a prerequisite we tolerate: it is the foundation the whole course is built on. Every AI concept enters through a structure you can reason about, and pairs, examples, and deliverables calibrate to your level.

You should have

  • A degree — or ongoing studies — in civil engineering

    any seniority, including students: pairs and deliverables adapt to your level

  • Conversational familiarity with an AI assistant such as Claude

    you’ve chatted with an AI before

  • Basic Python reading ability helps

    you can follow a script — but you won’t write code from scratch

  • A laptop, a stable connection, and 3 focused hours per session

You don’t need

  • Any prior experience with agents, APIs, or programming AI

  • Licenses for SAP2000, ETABS, or Midas

    the entire course runs on In-Structure AI and open tools, at zero software cost to you

  • A machine-learning background

    we build your mental model from zero, through experiments, not lectures

  • Any prior experience with OpenSees or finite element software packages

Why us

We teach this because we build it.

We’ve built more than 30 AI products for companies across very different sectors — working software, not slideware. That’s how we found the real bottleneck: it isn’t the technology, it’s that teams lack the judgment to use it well. So this program teaches what we practice every day — building with AI, not talking about it.

Your laboratory: In-Structure AI

You don’t learn on toy demos. In-Structure AI — our own AI-native structural platform, running on production agents that diagnose and correct real buildings — is your laboratory for the sprint, free for every enrolled engineer. Every concept runs live, on a real structure you can inspect.

How we teach

Build to understand. Break to learn.

No theory-first lectures. Every session follows the same rhythm: an activation problem you face before any explanation, a guided interactive artifact that makes the theory visible and manipulable, a pair construction lab, a failure clinic where you deliberately break the system and diagnose it, a transfer task to your own practice, and a written reflection.

The sessions

What each session covers, and what you leave with.

Session 01 · Understand

How LLMs work — and when they lie

3 h · live

Why can an AI sound like a senior engineer — and still be wrong?

Learning goals

  • Explain how an LLM works — tokens, context, next-word prediction — using a structural model as your example, to predict when AI will help you and when it will fail you.
  • Induce, detect, and correct hallucinations — including a fabricated code clause — to turn “fluency is not evidence” into an operating reflex.
  • Audit an AI conversation about a building, classifying every claim as grounded, teaching, or inference, to know exactly which statements you could sign your name under.
  • Engineer prompts as control interfaces — role, audience, structure, verification — to command output quality instead of hoping for it.

Topics

  • 01.1Opening challenge: a complete building analyzed, diagnosed, and designed by AI in the first fifteen minutes — driven by you
  • 01.2Tokens: how an AI reads your words — and your structural model
  • 01.3Next-token prediction: where fluent engineering answers really come from
  • 01.4Autoregressive generation: why a confident wrong start drags the whole answer with it
  • 01.5The context window: what the AI can actually see — and what it silently guesses
  • 01.6Temperature and sampling: tuning determinism when AI writes engineering code
  • 01.7Hallucination and grounding: the trap — a fabricated code clause your judgment must catch
  • 01.8Grounded vs. inferred claims: auditing an AI conversation about your building, line by line
  • 01.9Prompting as a control interface: one structural question, five prompt designs, five different answers
  • 01.10The Good Answer Contract: your reusable quality checklist for AI in engineering

How it’s taught

You face the activation challenge before any theory. Then the LLM Mechanics Explorer — an interactive artifact with a live tokenizer, probability bars, and a temperature slider — makes the mechanics visible. Pair labs follow: the five-prompt experiment and the hallucination clinic, where you make the AI fail on purpose and diagnose why.

You leave with

Your LLM Behavior Field Guide: your mental model, three failure modes you produced yourself, your best prompt patterns, and your Good Answer Contract — plus one audited AI conversation with every claim labeled.

Between sessions · Bring one real interaction where an AI ignored or forgot your professional standards (≈20 min). It becomes Session 2’s raw material.

Session 02 · Analyze

From prompts to systems — your expertise, persistent

3 h · live

Why does the AI forget your standards — and what belongs in a prompt, a project, a knowledge base, or a skill?

Learning goals

  • Build a persistent AI system — project instructions plus curated design-criteria knowledge — to stop re-explaining your standards in every conversation.
  • Write the modeling standard file an AI must always respect — units, conventions, mandatory checks — to make compliance with your practice automatic.
  • Specify a reusable skill with a rigid input/output schema to package one piece of your expertise for unlimited, reliable reuse.
  • Defend your instructions against untrusted data to keep design constraints intact when AI meets the real world.

Topics

  • 02.1Why the AI forgets your standards: the instruction stack — profile, project, knowledge, skill, prompt
  • 02.2Building your Structural Design Assistant: project instructions and curated design-criteria knowledge
  • 02.3The modeling standard file: units, conventions, and mandatory checks the AI must always respect
  • 02.4Protecting your constraints: a hands-on prompt-injection duel
  • 02.5Interactive artifacts: when a tool beats an answer — building a P-M diagram explorer
  • 02.6Skills: packaging your expertise — drift reports, model QA, quantity takeoff, load combinations
  • 02.7Schemas: rigid inputs and outputs that make automation reliable
  • 02.8Failure clinic: conflicting layers, overbroad skills, stale knowledge

How it’s taught

The Instruction Stack Simulator lets you toggle each layer on and off and watch the assistant’s answers change. Then three pair labs in sequence — project, artifact, skill — followed by the injection duel: you attack a peer’s instructions, they attack yours, and both designs come back stronger.

You leave with

A working Structural Design Assistant: project instructions, your modeling standard file, and one skill specification with schema — the seed of your professional AI system.

Between sessions · The cohort’s best skill gets implemented into In-Structure AI before Session 3 — and demoed, shipped and running, when we reconvene. Your work becomes part of the lab you learned it in.

Session 03 · Apply

The agentic paradigm — the loop that fixes a building

3 h · live

How does an AI agent correct a building by itself — and when must it stop and ask you?

Learning goals

  • Explain the agentic loop — Thought → Action → Observation → stop — by replaying a production agent correcting a real building, to understand agents from evidence, not hype.
  • Design tool interfaces for a structural agent — schemas, failure modes, guardrails — to make automation reliable enough for engineering.
  • Define stop rules and human checkpoints to keep professional responsibility exactly where it belongs: with the engineer.
  • Explain how open protocols connect AI to engineering platforms to see how agents reach real tools — and how yours will.

Topics

  • 03.1When prompting isn’t enough: “make this building comply with drift limits”
  • 03.2The tool-calling handshake: the model, the host, and the analysis engine
  • 03.3The ReAct loop: Thought → Action → Observation → stop
  • 03.4Replaying a production agent: watch the platform diagnose and correct a real building, step by step
  • 03.5Designing tool interfaces: the Drift Compliance Agent — schemas, failure modes, guardrails
  • 03.6Stop rules and human checkpoints: nothing changes a structure without an engineer’s approval
  • 03.7MCP: the open protocol that connects AI to engineering platforms
  • 03.8Fault injection: corrupt a tool result, watch the reasoning drift, install the correction

How it’s taught

A pen-and-paper handshake first — one of you plays the model, one the host, one the analysis engine — so the mechanics live in your hands before any screen. Then the Agent Trace Player: play, pause, and step through a real agent run on a real building, with a fault injector that lets you corrupt results mid-flight and watch the agent recover — or fail.

You leave with

Your Agent Design Sheet: goal, tools, schemas, a full reasoning trace, stop conditions, human checkpoints, and failure modes — the complete blueprint of a structural agent.

Between sessions · Choose the workflow from your own practice that your capstone will architect, and list every tool it would need (≈30 min).

Session 04 · Create

Agentic architectures — the platform unveiled, your design defended

3 h · live

Simple prompt, workflow, or agent — and how do you justify the complexity?

Learning goals

  • Distinguish workflows from agents and match six architecture patterns to structural engineering tasks to choose complexity deliberately instead of by fashion.
  • Map In-Structure AI’s complete architecture onto the patterns you now command to prove that the magic of hour one is engineering you understand.
  • Architect an AI workflow from your own practice — pattern, tools, evaluation, checkpoints, risk — to leave with a design ready to implement, not an idea.
  • Defend your architecture before the cohort to demonstrate the deepest outcome of this sprint: architectural judgment.

Topics

  • 04.1Workflows vs. agents: the distinction that prevents overengineering
  • 04.2The pattern catalog, each with its structural embodiment: augmented LLM, prompt chaining, routing, orchestrator-workers, evaluator-optimizer, autonomous agents
  • 04.3The grand reveal: In-Structure AI’s complete architecture — mapped by you, pattern by pattern
  • 04.4Inside a coding agent: dissecting a real autonomous session — self-checks, rollbacks, and the moments it should have asked
  • 04.5Verification gates: your acceptance protocol as deterministic evaluation gates
  • 04.6The complexity rule: the best architecture is the simplest one that passes the evaluation with acceptable risk
  • 04.7Capstone: the architecture canvas for an AI workflow from your own practice
  • 04.8Defense and presentations — plus your 30-day implementation plan

How it’s taught

Patterns first, on the Architecture Pattern Canvas — a node-based board where you assemble and test pipelines. Then the reveal: the platform’s real architecture, mapped by you onto the patterns you now command. The session closes with capstone defenses before the cohort.

You leave with

Your capstone architecture canvas for an AI workflow from your own practice — pattern, tools, evaluation gates, checkpoints, and risk — defended before the cohort, plus a 30-day implementation plan.

What you take

Six things you will verifiably be able to do

We don’t promise inspiration — we promise capabilities, and we verify them. Each outcome below is confirmed through your deliverables and the LMS before the sprint ends.

  1. 01

    Explain how an LLM works — tokens, context, prediction, hallucination — using a structural example, and diagnose its failure modes

    Field Guide + exit evidence · S1

  2. 02

    Audit an AI conversation and separate grounded claims from inference before acting on them

    Annotated conversation submitted · S1

  3. 03

    Build a persistent AI system: project instructions, curated knowledge, and a modeling standard

    Working assistant reviewed by peers · S2

  4. 04

    Specify a reusable skill with a rigid input/output schema

    Skill spec validated; best one shipped into the platform · S2–S3

  5. 05

    Trace, explain, and design an agent — tools, schemas, stop rules, and human checkpoints

    Agent Design Sheet · S3

  6. 06

    Choose and defend an agentic architecture for a workflow from your own practice

    Capstone canvas presented and defended · S4

The laboratory

In-Structure AI — included, free, yours

In-Structure AI is an AI-native structural analysis and design platform. It models buildings, runs seismic analysis, diagnoses irregularities with AI agents, corrects models automatically, verifies drift, designs reinforced concrete per ACI 318-22 and NSR-10, and produces construction drawings. Every concept in this course — context, grounding, skills, agent loops, architectures — exists live inside the platform, where you can watch it work on a real building. Full access at no cost for every enrolled engineer: our business is education, not licenses.

Glass box

Behind every result is readable text — the model, the agent’s reasoning, the code reference. Nothing is hidden, so every abstract concept becomes something you can inspect.

Production agents

You’ll trace agent loops, tool calls, and architecture patterns on the platform’s own working agents — the same ones that diagnose and correct buildings — not on invented classroom demos.

Learning lab

The best skill designed by this cohort gets implemented into In-Structure AI during the sprint — and demoed, running, before the course ends. You’ll leave your mark on the lab.

What’s included

Everything around the 12 hours

Platform — In-Structure AI, free

Full platform access throughout the sprint and the 30-day follow-up window. No licenses to buy — for this course or for the commercial software it replaces.

Artifacts — four interactive learning tools

The LLM Mechanics Explorer, Instruction Stack Simulator, Agent Trace Player, and Architecture Pattern Canvas — yours to keep and reuse after the course.

Personalization — a program with your face

An onboarding form before Session 1 calibrates pairs, examples, and your capstone. Deliverable ambition adapts to your seniority — finished beats abandoned.

Materials — notes that answer back

AI-generated class notes per session, wired to a notebook that has read everything covered. Session recordings. Your guides, specs, and canvases — all yours to keep.

Tracking — an LMS that knows where you are

Progress tracked per outcome, deliverables reviewed, and instruction itself measured and corrected session to session.

Follow-up — 30 days, not goodbye

A structured 30-day plan to land your capstone at work, with one 1-on-1 check-in to unblock you.

Logistics

Format, schedule, and what you need

Format

  • 4 live virtual sessions of 3 hours (12 hours total), hands-on throughout — this is a workshop, not a webinar
  • Cohort of 10 engineers. The cohort launches once 10 seats are confirmed; you’ll receive the schedule upon confirmation
  • Sessions delivered in English or Spanish depending on the cohort
  • ~20–30 minutes of between-session work after Sessions 1, 2, and 3

Requirements

  • A laptop with a modern browser; camera and microphone — pairs and presentations are part of the method
  • A Claude account — plan guidance provided at enrollment
  • In-Structure AI access is provisioned by us — nothing to buy or install for the platform
  • 3 focused hours per session — phones down, hands on

What’s next

This is the first rung of a ladder

Sprint 1 gives you the architecture of agentic AI, proven on real structures. Your Sprint 1 capstone is the entry ticket to Sprint 2. The ladder continues:

Sprint 2

Script and automate

Generating and verifying structural models at scale.

Sprint 3

Extend

Building new capabilities into In-Structure AI itself.

Sprint 4

Build

Shipping your own AI tools.

Your program is designed after the diagnosis.

This syllabus is one cohort’s. Yours is built around your team’s real level — not someone else’s.

Bring the classroom to your team

Start with a 30-min call