You do not need to become a data scientist. But in 2026 you cannot sit through a software demo, a webinar, or a tender meeting without someone saying "our agent uses computer vision and a bit of RAG" — and expecting you to nod.

This guide fixes that. It is a plain-English, construction-first tour of the AI terms you actually hear in estimating, takeoff, BIM, and drawing analysis. For each one you get: what it means without the jargon, why it matters in AEC, a construction example, how a tool like Kreo uses (or could use) it, and the misconception that trips people up.

It is educational, not a pitch. The goal is simple: next time these words come up, you can tell the real capability from the marketing.

How to read this guide

Terms fall into two groups:

• Core terms — the ones that directly shape takeoff, estimating, and drawing work. Full breakdown for each.
• "If a vendor says this…" terms — infrastructure words you will hear in demos and webinars. Short boxes so you know what they mean and whether they matter to you.

At the end: a one-page glossary and a short list of terms worth learning over the next year.

Two ideas cut across everything, so hold them from the start:

1. Nothing here is magic. Every "AI" feature is a model making a prediction, plus software around it. Predictions can be wrong. The good products are the ones built to let you check and correct fast.
2. "AI" is not one thing. A chatbot, a door detector, and an autonomous agent are wildly different technologies wearing the same two-letter badge. Most confusion in AEC meetings comes from treating them as the same.

Part 1 — Core terms

Computer Vision (CV)

Plain English: Teaching software to "see" — to look at an image or drawing and identify what is in it and where.

Why it matters in AEC: Your entire trade is visual. Plans, elevations, sections, site photos, scans. Computer vision is the branch of AI that turns those pixels into things a computer can measure and count. It is the engine under almost every "AI takeoff" claim.

Construction example: You upload a floor plan. Computer vision locates every door, window, and room boundary on the sheet — the same shapes you would otherwise trace by hand.

How Kreo uses it: Kreo's core takeoff tools are computer vision applied to construction drawings — detecting rooms, walls, doors, windows, and custom elements, then turning them into areas, lengths, and counts you can edit.

Common misconception: "Computer vision reads the drawing like an engineer." It does not understand intent or code compliance. It recognizes visual patterns. That is powerful for measurement and useless for judgment — which is exactly why a human stays in the loop.

OCR (Optical Character Recognition)

Plain English: Turning text that lives inside an image into text a computer can actually read and search.

Why it matters in AEC: So much of a drawing's meaning is in the text — room names, door tags, dimensions, revision clouds, title block info, notes. A pixel picture of the word "FD60" means nothing until OCR turns it into the string FD60.

Construction example: OCR reads the schedule and tags on a plan so the software can link "D-01" on the drawing to "D-01, fire door, 60 min" in the door schedule.

How Kreo uses it: Kreo reads labels, tags, and text layers — including on messy scanned PDFs — so measurements can be named, grouped, and cross-referenced instead of arriving as anonymous polygons.

Common misconception: "OCR is basically solved." On clean digital exports, yes. On a photocopied-of-a-photocopy scan at an angle, accuracy drops, and that is where a lot of "the AI got it wrong" complaints actually come from — bad source text, not a bad model.

Object Detection

Plain English: Finding specific things in an image and drawing a box around each one — "there's a door here, a door there, a window up top."

Why it matters in AEC: Counting is a huge chunk of takeoff, and it is mind-numbing by hand. Object detection is the technique that finds and counts repeated elements across a sheet — or, in stronger products, across an entire drawing set.

Construction example: "How many sprinkler heads / sockets / parking bays are on this sheet?" Object detection finds each instance and tallies them.

How Kreo uses it: Point at one element and Kreo finds and counts every matching object across the pages of your drawing — the "find one, get them all" workflow.

Common misconception: "If it detects 200 doors, there are 200 doors." Detection produces candidates, not gospel. It can miss faint symbols and double-count overlapping ones. The value is a 95%-there count you verify in seconds instead of clicking 200 times.

Segmentation

Plain English: Instead of a rough box around an object, segmentation traces its exact outline — pixel by pixel.

Why it matters in AEC: Boxes are fine for counting; areas need shapes. Segmentation is what lets AI produce an accurate room polygon, floor area, or paved region rather than a crude rectangle.

Construction example: Measuring the floor area of an irregular, L-shaped room. A bounding box would over-count; segmentation follows the actual walls, so the area is right.

How Kreo uses it: Kreo identifies and highlights the actual polygon of a room or area, so the measurement matches the real geometry — the basis for GIA/GEA-style area takeoff.

Common misconception: People blur "detection" and "segmentation." Detection = is it there and where, roughly. Segmentation = what is its precise shape. When a vendor says "AI measures areas," they mean segmentation — ask to see it on a messy, non-rectangular room.

Multimodal AI

Plain English: A model that can work with more than one kind of input at once — text and images and structured data — instead of just one.

Why it matters in AEC: Your work is inherently multimodal. A takeoff is drawings + text (schedules, specs) + numbers (dimensions, rates). Multimodal AI can look at a drawing and read your typed instruction about it in the same breath.

Construction example: You type "measure all the CAT A office floor area, exclude cores and risers," and the model uses both your words and the visual plan to produce the measurement.

How Kreo uses it: Combining vision (the drawing) with language (your prompt / task) is what lets you drive takeoff by describing what you want, not just clicking tools.

Common misconception: "Multimodal means it understands everything about my project." It means it can ingest multiple formats. It still does not know your firm's measurement conventions unless the workflow is designed to respect them.

Large Language Model (LLM)

Plain English: The technology behind ChatGPT and its cousins — a model trained on enormous amounts of text that predicts language well enough to answer, summarize, and follow instructions.

Why it matters in AEC: LLMs are the "understanding language and giving answers" layer. In construction tools they power the chat you talk to, the plain-English report configuration, and the reasoning that turns "build me a cost plan grouped by floor" into structured actions.

Construction example: Asking, in plain English, "summarize the differences between Revision C and Revision D of this drawing set" and getting a readable list back.

How Kreo uses it: Language models sit behind conversational takeoff refinement and prompt-driven report structuring — the "talk to your project" experiences — grounded in your actual drawing data rather than free-floating answers.

Common misconception: "The LLM does the takeoff." It does not measure anything. It is the conversation and reasoning layer; the measuring is computer vision. When a chatbot "does a takeoff," an LLM is orchestrating vision tools underneath — or it is faking it.

AI Agents

Plain English: AI that doesn't just answer — it takes actions to complete a task, often in several steps, inside your software.

Why it matters in AEC: This is the leap from "chatbot that talks about your drawing" to "assistant that does the measurement, builds the report, and exports it." Agents can chain steps: detect → measure → classify → export.

Construction example: "Do the takeoff for level 2 and give me a BoQ." An agent detects the elements, measures them, groups the quantities, and produces the bill — as a sequence of actions, not a paragraph of advice.

How Kreo uses it: Caddie is Kreo's AI takeoff agent — it reads drawings, runs measurements, and delivers quantities as actions inside your project, under your control, not just as chat answers.

Common misconception: "Agent" = "chatbot with a fancy name." No. A chatbot returns text; an agent changes the state of your project (creates measurements, edits reports). If a "agent" only ever gives you words to copy-paste, it is a chatbot.

Agentic AI

Plain English: The broader shift toward systems that plan and pursue a goal semi-autonomously — deciding the steps themselves, calling tools, and adapting — rather than doing one command at a time.

Why it matters in AEC: "Agentic" is the 2026 buzzword of the year. It signals software that can take a fuzzy goal ("price this fit-out") and work through the sub-tasks. Understanding it helps you separate genuine autonomy from a rebranded macro.

Construction example: Give the system a goal — "produce a first-pass estimate for this warehouse shell" — and it plans the sequence: find the areas, count the elements, apply rates, flag what it is unsure about.

How Kreo uses it: Kreo's direction is agentic takeoff: describe the outcome, approve the plan, let the agent execute the repetitive middle while you own scope, risk, and commercial judgment.

Common misconception: "Agentic AI means hands-off." The good implementations are the opposite — they keep an approval step and show their plan because autonomy without oversight is a liability in a priced bid. Autonomy is a dial, not a switch.

Prompt Engineering

Plain English: The skill of writing instructions to an AI so it does what you actually want — being specific about scope, format, and constraints.

Why it matters in AEC: As tools become prompt-driven, the quality of your instruction increasingly determines the quality of the output. "Measure the rooms" and "measure net internal floor area of all offices, exclude circulation and cores, group by level" give very different results.

Construction example: Turning a vague "give me quantities" into "count all single-socket outlets on power layout sheets E-201 to E-205, exclude data points, output as a table by room."

How Kreo uses it: Prompt-driven measurement and AI-configured reports mean a well-phrased instruction gets you a usable result the first time — and Kreo grounds prompts in your real drawing data to keep answers specific.

Common misconception: "Prompt engineering is a fad / a fake job." At the personal level it is just learning to ask precisely — the same skill as writing a clear scope note. You do not need a course; you need to be specific.

AI Workflows

Plain English: Stringing multiple AI steps (and human checks) into a repeatable pipeline, instead of using one clever feature in isolation.

Why it matters in AEC: Real value comes from the chain: understand the sheet → detect → measure → classify → hand off to estimating. A single AI trick is a demo; a workflow is a change to how your week runs.

Construction example: Upload set → AI sets scale → detect and measure elements → you review and correct → quantities flow into a live report → export BoQ. Each stage feeds the next.

How Kreo uses it: Kreo is built as a workflow, not a gimmick — measurements stay linked to drawings and to live reports, so a revision ripples through instead of forcing a manual redo.

Common misconception: "One magic button does everything." Serious tools expose the workflow — with checkpoints — precisely so you can trust and audit the output. A single opaque button is harder to defend when the bid is questioned.

Function Calling

Plain English: The mechanism that lets a language model actually use tools — call a measuring function, run an export, query a database — instead of only producing text.

Why it matters in AEC: This is the plumbing that turns a chatbot into an agent. When you tell an AI "measure this and export a BoQ," function calling is how the language model reaches out and triggers the real measurement and export functions.

Construction example: You ask for a count of fire doors. The model calls the detection function, gets 42, then calls the report function to insert "42 fire doors" into your schedule — real actions, not a guessed number.

How Kreo uses it: Function calling is how a takeoff agent connects language ("do the takeoff") to the product's real capabilities (detect, measure, report, export) — so the answer is grounded in an actual operation, not invented.

Common misconception: "It's a technical detail I can ignore." It is the single best question to ask a vendor: does your AI actually call your measurement tools, or just describe what it would do? The answer tells you if it is an agent or a talker.

Zero-shot learning

Plain English: When an AI can handle a task or recognize something it was never specifically trained on, using its general knowledge.

Why it matters in AEC: Your projects are full of oddities — a custom symbol, an unusual element, a one-off legend. Zero-shot capability means the AI can take a reasonable first swing without you training it first.

Construction example: A drawing uses a non-standard symbol for a bespoke fixture. A zero-shot-capable model still attempts to find and count it based on your description, with no prior examples.

How Kreo could use it: Handling unusual or project-specific elements on the first attempt — you describe it, the AI tries — rather than requiring a trained template for every symbol.

Common misconception: "Zero-shot is as good as trained." It is a strong starting point, not peak accuracy. For rare or ambiguous symbols, giving a couple of examples (see few-shot) usually beats relying on zero-shot alone.

Few-shot learning

Plain English: Teaching an AI a new task by showing it just a handful of examples — not thousands.

Why it matters in AEC: It is the practical middle ground between "hope zero-shot works" and "commission an expensive custom model." Show the tool two or three examples of your unusual element and it generalizes.

Construction example: You mark three instances of a custom pump symbol; the AI then finds the remaining forty across the set.

How Kreo uses it: "Teach by example" is exactly this — you tag a few instances of a custom object and Kreo detects the rest, adjusting similarity so you control how strict the match is.

Common misconception: "I have to train a model, that means data science." Few-shot is the opposite of that — the whole point is that a few clicks replace a training project. If a tool needs thousands of your examples to count a symbol, that is a weakness, not sophistication.

Part 2 — "If a vendor says this…"

You will hear these in demos and webinars. You rarely need to do anything with them — you just need to know what they mean and whether they should change your decision.

RAG (Retrieval-Augmented Generation)

• What it means: Before answering, the AI retrieves relevant documents (your specs, standards, past projects) and answers based on them — instead of relying only on general training.
• Why you'd hear it: It is how a vendor claims their chatbot is "grounded in your data" and less prone to making things up.
• AEC example: "What's our standard spec for external doors?" → the AI pulls your actual spec library and answers from it.
• Watch for: RAG reduces, but does not eliminate, wrong answers. Ask what it retrieves from and whether it shows sources.

Embeddings

• What it means: A way of turning text or images into lists of numbers that capture meaning, so software can measure how similar two things are.
• Why you'd hear it: It is the tech behind "smart search" and "find similar" features.
• AEC example: Finding all past projects "similar to this hospital fit-out" even when none share the exact keywords.
• Watch for: Purely an under-the-hood concept. You never touch it; you just benefit from better search.

Vector Database

• What it means: A database built to store embeddings and find the "nearest" (most similar) ones fast.
• Why you'd hear it: It is the storage layer that makes RAG and similarity search work at scale.
• AEC example: Instantly retrieving the three most relevant clauses from thousands of pages of specs.
• Watch for: This is a plumbing choice. It is not a feature you should be paying attention to as a buyer — outcomes are.

Fine-tuning

• What it means: Taking an existing model and further training it on specialized data so it performs better on a narrow task.
• Why you'd hear it: Vendors say it to signal "our AI is customized for construction," not generic.
• AEC example: A detection model further trained on thousands of construction drawings so it recognizes AEC symbols better than an off-the-shelf model.
• Watch for: It is often over-claimed. For many tasks, good prompts + a few examples (few-shot) match fine-tuning at a fraction of the cost. Ask what problem the fine-tuning actually solved.

MCP (Model Context Protocol)

• What it means: An open standard for connecting AI models to external tools and data sources in a consistent way — think "a universal adapter for AI to talk to other software."
• Why you'd hear it: It is a 2025–2026 industry buzzword for interoperability; vendors mention it to signal their AI can plug into your other systems.
• AEC example: An AI assistant that can reach into your document management or cost system through a standard connector instead of a bespoke integration.
• Watch for: Useful literacy, but as a buyer you care about whether the integration exists and works — not the protocol name. "We support MCP" is a means, not an outcome.

Quick comparison: the words people mix up

• Object detection vs Segmentation — Detection = box around a thing (good for counting). Segmentation = exact outline (needed for areas).
• Chatbot vs AI Agent — Chatbot returns text. Agent takes actions in your software.
• LLM vs Computer Vision — LLM understands language. CV understands images/drawings. Takeoff needs CV; the chat around it uses an LLM.
• Zero-shot vs Few-shot — Zero-shot = no examples given. Few-shot = a handful of examples given.
• Fine-tuning vs Prompting/Few-shot — Fine-tuning retrains the model (expensive). Prompting/few-shot steers it at use-time (cheap).
• RAG vs Fine-tuning — RAG retrieves your documents at answer-time. Fine-tuning bakes in knowledge ahead of time.

The one mental model to keep

Most AEC "AI" products are a stack of three layers. Learn to spot them and you can decode almost any demo:

1. Perception (Computer Vision + OCR) — sees the drawing: detects, segments, reads text.
2. Reasoning (LLM) — understands your language and plans what to do.
3. Action (Agent + Function Calling) — actually runs the measurements, builds the report, exports.

A weak product has a great-looking layer 2 (a chatty demo) and almost nothing in layers 1 and 3. A strong takeoff product is real in all three — vision that measures accurately, language you can talk to, and actions that change your project. That is the difference you are trying to detect in every demo.

Glossary (one-line reference)

• Computer Vision (CV) — AI that "sees" images and drawings to identify and locate things.
• OCR — Turns text inside an image into readable, searchable text.
• Object Detection — Finds and boxes specific items — the engine of AI counting.
• Segmentation — Traces an object's exact outline — the engine of AI area measurement.
• Multimodal AI — Works with text, images, and data together, not just one.
• LLM — The language model behind chat, summaries, and instruction-following.
• AI Agent — AI that takes actions in software, not just gives answers.
• Agentic AI — Systems that plan and pursue a goal semi-autonomously.
• Prompt Engineering — Writing precise instructions to get the output you want.
• AI Workflow — A repeatable chain of AI steps and human checks.
• Function Calling — How an AI actually triggers real tools instead of only talking.
• Zero-shot — Handling a task with no prior examples.
• Few-shot — Learning a task from a handful of examples.
• RAG — Retrieves your documents before answering, to stay grounded.
• Embeddings — Numbers that capture meaning, enabling similarity search.
• Vector Database — Storage built to find the most similar embeddings fast.
• Fine-tuning — Extra training of a model on specialized data.
• MCP — An open standard connector between AI and other tools/data.

Worth learning over the next year

The vocabulary keeps moving. These are the terms most likely to show up in AEC conversations next — worth a five-minute read each before you need them:

• Foundation models — the giant general-purpose models everything else is built on.
• Human-in-the-loop (HITL) — designing workflows so a person reviews/approves AI output. In estimating, this is not optional.
• Confidence scores — when a model tells you how sure it is, so you can prioritize what to double-check.
• Hallucination — when an AI states something false with confidence; the core reason to verify.
• Synthetic data — computer-generated training data (e.g. generated drawings) used to improve detection.
• Active learning — the model asking you to label the cases it is least sure about, so it improves fastest.
• Model evaluation / benchmarking — how you (or an independent party) measure whether an AI is actually accurate.
• Guardrails — constraints that stop an AI from doing something out of scope or unsafe.
• Digital twin — a live data model of a built asset; increasingly where AI outputs land.

The bottom line

You do not need to build these systems. You need to recognize them — enough to ask the one sharp question that separates a real capability from a slide.

For takeoff and estimating, the sharpest version of that question is always the same: does the AI actually see my drawings accurately, and does it take real actions in my project — or does it just talk about them?

Everything in this guide is a way of answering that.