What isAgentic AI?
Before writing a single prompt or connecting a tool, you need a clear mental model of what an AI agent actually is — and isn't. This module builds that foundation with examples drawn directly from Normoyle's work: fabrication, structural steel, compliance documentation, and Tier 1 builder projects.
The difference that matters
Most people's first experience with AI is a chatbot — you type a question, it writes an answer. That's useful for one-off tasks: drafting an email, explaining a standard, summarising a document. But it has a hard limit: every response starts from scratch, and you have to do all the follow-through yourself.
An agentic AI is fundamentally different. Give it a goal and it figures out the steps, uses tools to gather what it needs, executes the work, checks its own output, and hands you a completed result — not a starting point.
You ask "what's the weld symbol for a fillet?" and it answers. One exchange. You still have to find the drawing, check the standard, write the NCR, and update the register — all yourself.
You say "review this drawing against AS/NZS 1554 and draft any NCRs." It reads the drawing, loads the standard, identifies non-conformances, drafts the NCRs, and returns a review-ready document.
Agents can call external tools — read files, query databases, run calculations, draft documents — and chain these actions across multiple steps without you steering each one.
Think of the difference this way. A chatbot is like ringing a colleague and asking them a question — you get an answer, then you go do the work. An agent is like briefing a capable project engineer — they take the brief, go away, gather what they need, produce the output, and come back to you with a completed draft ready for sign-off. The judgement and accountability stays with you. The legwork doesn't.
What this looks like at Normoyle
Abstract explanations only go so far. Here are four concrete examples of the difference between chat AI and agentic AI in Normoyle's context. These are the use cases the rest of this course covers in detail.
| Task | Chat AI approach | Agentic AI approach |
|---|---|---|
| RFQ quote Builder sends 4 drawing PDFs for a structural steel balustrade |
You ask it to help write the quote. You still read the drawings, extract dimensions, look up rates, and build the BOM yourself — then paste it in for help formatting. | Agent reads all 4 PDFs, extracts every section size and quantity, queries your cost database, calculates labour, and returns a complete draft BOM and quote. You review, adjust margin, sign off. |
| Drawing compliance check Checking weld symbols against AS/NZS 1554 |
You paste in a weld specification and ask if it looks right. It answers based on what you typed — you still have to manually check every drawing sheet. | Agent reads the drawing register, loads AS/NZS 1554, checks every weld callout on every sheet, flags non-conformances with clause references, and drafts NCRs for engineer review. |
| Procurement follow-up Steel delivery 5 days overdue on critical path |
You ask it to write a follow-up email. You provide the PO number, supplier, dates, and context — then edit and send yourself. | Agent reads your PO register every morning, identifies overdue items, flags critical path impacts, drafts follow-up emails for each supplier, and saves them to a review folder for the PM to approve and send. |
| RFI response Tier 1 builder asks a question about a connection detail |
You ask it to help draft a response. You still have to find the relevant drawing, look up the spec clause, and provide all the context before it can help. | Agent searches the drawing register for the relevant detail, retrieves the spec clause, cross-references the RFI register to avoid duplicate numbering, and drafts a complete professional response for the project engineer to review and issue. |
How an agent reasons: the loop
Every AI agent — regardless of platform — runs on the same basic loop. Understanding it helps you predict what the agent will do, catch where it might go wrong, and write better instructions.
The agent cycles through Perceive → Plan → Act → Observe until the task is done or it hits a checkpoint you've defined. At that point it stops and waits for a human — the engineer or PM — to review before anything proceeds further.
The loop applied to a Normoyle estimating job
Here's exactly what that loop looks like when the estimating agent processes a balustrade RFQ:
- Perceive — read the drawings Agent receives three PDFs. It reads every sheet: layout plan, post detail, handrail section. Extracts all text, dimensions, material callouts, and weld specifications. Notes what's missing or ambiguous.
- Plan — figure out what's needed Decides it needs to: (a) build a BOM from the extracted data, (b) query the cost database for unit rates, (c) calculate labour hours by task type, (d) flag the 4 items it couldn't confirm from the drawings, (e) draft the quote.
- Act — execute each step Queries the CSV cost database. Calculates quantities using the dimensions extracted. Applies labour rates from the rate card. Fills in the Normoyle quote template. Compiles the flagged items list.
- Observe — check the output Reviews its own BOM: are all drawing elements accounted for? Are units consistent (LM vs EA vs KG)? Are flagged items clearly identified? If something looks incomplete, it loops back and tries again.
- Human review — the non-negotiable gate Estimator receives the draft BOM, cost subtotal, and flagged items. Reviews each flag, applies margin, and signs off. Nothing leaves Normoyle without this step.
The four components of any agent
Every agent — no matter how simple or complex — is built from four components. You don't need to build any of them from scratch. You configure them.
The underlying AI (Claude, GPT-4, Gemini) that does the reasoning, reading, and writing. You choose which model to use and give it instructions via a system prompt. Think of it as hiring a highly capable person and writing their job description.
Functions the agent can call: read a PDF, query a spreadsheet, search a folder, draft a document, send a notification. You decide which tools to connect. A Normoyle estimating agent needs: read PDF, query cost database, write quote document.
What the agent can access and remember. Short-term: the current job's drawings and data. Long-term: your cost database, past quotes, rate cards. Without the right memory, the agent can't apply Normoyle-specific knowledge.
How multiple steps or agents connect. Simple: one agent, one task. Complex: a manager agent delegates to specialist sub-agents — one reads drawings, one checks standards, one drafts the document. You build this as your confidence grows.
For the estimating pilot, you configure: (1) the system prompt — Claude's role and rules, (2) a cost database CSV — uploaded as a reference file, (3) the labour rate card — included in the system prompt. That's it. No coding required if you use Claude Projects. The model, the tools, and the infrastructure are all provided — you write the instructions and supply the data.
Where agents work well — and where they don't
Understanding the boundaries is as important as understanding the capabilities. Agents fail in predictable ways — and knowing those failure modes lets you design around them.
| Task type | Fit | Why — Normoyle context |
|---|---|---|
| Quantity takeoff from drawings | EXCELLENT | Structured input, objective output, easy to verify against known answers |
| Drafting RFI responses, progress reports, supplier chasers | EXCELLENT | Language generation from structured data is where AI consistently delivers |
| Standards checking (AS/NZS 1554, AS 4100) | GOOD | Agent can cross-reference text reliably; engineer confirms and signs off findings |
| Procurement tracking and follow-up drafting | GOOD | Repetitive, rule-based, high volume — exactly what agents handle well |
| Estimating complex bespoke fabrication | PARTIAL | Agent handles standard elements; estimator must lead on novel or high-risk items |
| Structural engineering calculations and sign-off | NO | Requires a licenced engineer; agents can assist drafting but never replace sign-off |
| Interpreting ambiguous scope or negotiating with clients | NO | Requires relationship knowledge, commercial judgement, and accountability |
| Defence-classified document handling | RESTRICTED | Security classification must be verified before any AI tool is used — see Module 5 |
How agents go wrong — and what to do about it
Agents fail in specific, predictable ways. None of these are reasons to avoid agents — they're reasons to design proper review gates. Every failure mode below has a straightforward mitigation.
The agent confidently states something that isn't in the source material — inventing a material grade, a clause reference, or a quantity. Mitigation: require the agent to cite where each fact came from, and flag anything it can't source directly.
The agent extracts what's on the drawing but misses implied scope — fixings not detailed, surface finishes specified elsewhere, or site-specific requirements from a separate spec document. Mitigation: provide all relevant documents, not just the drawings.
The agent applies rates from a cost database that hasn't been updated. Steel prices move — a 6-month-old rate card can put a quote 10–15% off before you start. Mitigation: assign a database owner and set a 60-day update reminder.
Confusing linear metres with square metres, kilograms with tonnes, or counting elements when it should be measuring length. Mitigation: define unit rules explicitly in the system prompt with examples for each element type.
Producing a complete-looking output without flagging genuine uncertainties — especially dangerous on complex or unusual items. Mitigation: instruct the agent to flag anything it's less than 100% certain about. Never let it suppress uncertainty.
The agent's outputs gradually change as the system prompt is edited over time — rules contradict each other, old instructions conflict with new ones. Mitigation: version control your system prompts. Keep a dated copy before every edit.
Every agent output that leaves the business — a quote, a compliance record, an RFI, a supplier communication — must be reviewed and signed off by a qualified person before issue. Agents are draft generators and admin automators. The professional responsibility for every document remains with the engineer or PM who approves it. This doesn't change as agents become more capable — it's a business principle, not a technology limitation.
The AI landscape: what tool does what
There are a lot of AI products on the market and it's easy to get confused about which one does what. Here's a plain-English guide to the tools relevant to Normoyle, and where each fits.
| Tool | What it is | Best use at Normoyle | Not suitable for |
|---|---|---|---|
| Claude (Anthropic) | AI assistant and agent platform — the tool this course is built around | Estimating agent, compliance docs, RFI drafting, all course exercises | Sending emails automatically without review |
| ChatGPT (OpenAI) | Similar capability to Claude — good for general drafting and Q&A | General writing, brainstorming, explaining concepts | Client project data (check data terms before use) |
| Microsoft Copilot | AI integrated into Word, Excel, Outlook, Teams | Drafting in Word, summarising emails, Excel formula help | Complex multi-step agent workflows |
| n8n | Workflow automation tool — connects Claude to your files, email, databases | Automated PO tracking, scheduled reports, file processing | Tasks requiring real engineering judgement |
| Claude API | Direct programmatic access to Claude — maximum control and integration | Custom agents with ERP/CAD integration, automated pipelines | Non-technical users without developer support |
Hands-on exercise: spot the agent
This exercise doesn't require any software. It's about building the mental model before you touch a tool.
- Pick a task you did this week that took more than an hour Something repetitive and document-heavy — writing up a quote, checking a drawing register, drafting a supplier email, compiling a progress report. Write it down in one sentence: "I [verb] [object] by [method]."
- Map it to the agent loop For your task, identify: What did you perceive (what inputs did you read)? What did you plan (what steps did you know you had to take)? What did you act on (what did you actually do)? What did you observe (how did you check your work)?
- Identify the tools you used List every application, file, or data source you touched during the task — PDFs, spreadsheets, emails, drawing registers, standards documents, supplier price lists. These are the tools an agent would need access to.
- Assess the fit Using the "where agents work well" table above, score this task: Is it repetitive? Are the inputs structured? Can the output be objectively verified? Is there a human check at the end? The more "yes" answers, the better an agent candidate it is.
- Bring it to the group discussion Come prepared to describe your task and your assessment. The group will work through the best candidates together and prioritise which ones to pilot first.