AI Agents and Automation
Module 8 · Build Custom GPTs, Automate Workflows, Deploy Agents
Builds on: Modules 4-6 (prompting, research, productivity)
After completing this module, you will be able to:
- Explain the difference between a chatbot (reactive) and an agent (proactive)
- Design, build, and deploy a custom GPT for your specific use case
- Write effective system instructions that keep AI assistants on task
- Identify workflows that benefit from automation — and ones that don’t
- Build a simple automation using no-code tools
- Apply human-in-the-loop principles to agent design
- Evaluate when a custom GPT, an automation, or a full agent is the right solution
The Professor Who Deleted His Slides
In Fall 2025, a statistics professor at a mid-size public university tried an experiment that his colleagues thought was reckless. He taught two sections of the same course — MATH 3200, Probability and Statistics. Section A got the traditional experience: lecture slides, handwritten notes on the board, homework submitted through Canvas.
Section B got something radically different. No static slides. No lecture notes. Instead, every topic had its own custom AI tutor — a GPT built specifically for that chapter, loaded with the professor’s own notes, examples, and teaching philosophy. Every homework assignment had its own linked GPT for guided problem-solving. Students submitted both their written work AND the GPT conversation transcript showing their reasoning process.
The professor wasn’t being lazy. He was running a controlled experiment.
The results: On Exam 1, the AI section averaged 72.20 compared to the traditional section’s 68.20 — a 4-point advantage, with similar standard deviations (~21 in both groups). Students in the AI section reported that the most helpful features were R code assistance (9 mentions), alignment with class content (6), clear explanations (6), and step-by-step guidance (4).
That professor was Dr. Anjana Yatawara — the author of this course. And the custom GPTs he built for that experiment are the foundation of what you’ll learn in this module.
This isn’t theory. You’re learning from someone who built it, tested it, measured it, and has the data.
The ELEVATE result (AI section 72.20 vs traditional 68.20) isn’t alone. In Fall 2023, physics lecturer Gregory Kestin and colleagues at Harvard ran a preregistered randomized controlled trial (N=194 undergraduates) comparing an AI tutor built on GPT-4 against active-learning classroom sessions. Both topics, both directions, the AI tutor group showed more than twice the learning gains, spent less time on the lesson, and reported higher engagement and motivation (Kestin et al., 2025, Scientific Reports).
Critically, the AI tutor was not just ChatGPT — it was a carefully designed custom system with pedagogical principles embedded in the prompts and full answer keys grounding its responses. The design choices matter. A generic ChatGPT tutor does not produce these results. A constrained, knowledge-loaded, pedagogy-informed one does. That’s the architecture you’ll learn to build in this module.
Chatbots vs Agents: What’s the Difference?
These terms get used interchangeably, but they’re different:
| Feature | Chatbot | Agent |
|---|---|---|
| Behavior | Reactive — waits for your input, responds | Proactive — can plan, act, and follow up |
| Scope | Answers questions within a conversation | Can take actions: search the web, run code, send emails, manage files |
| Memory | Usually forgets between sessions | Can maintain context across sessions |
| Autonomy | Does what you ask, nothing more | Can break complex tasks into subtasks and execute them independently |
| Example | ChatGPT answering “What’s the weather?” | An agent that checks your calendar, sees you have an outdoor meeting, checks the forecast, and messages you to bring an umbrella |
Custom GPTs sit in the middle. They’re more than a basic chatbot (they have persistent instructions and uploaded knowledge) but less than a full agent (they can’t take autonomous actions across systems). They’re the sweet spot for most people — powerful enough to be genuinely useful, simple enough to build without programming.
- “Custom GPTs are permanent” — They need maintenance. When your knowledge files change (updated syllabus, new policies), the GPT needs updating too. Budget time for upkeep.
- “GPTs remember everything” — Custom GPTs have persistent INSTRUCTIONS but not persistent MEMORY of past conversations. Each user session starts fresh.
- “More knowledge files = better” — Too many files can confuse the model. Upload only what’s directly relevant. A focused GPT with 3 files outperforms a bloated one with 30.
- “Agents are always better than chatbots” — Agents introduce autonomy, which introduces risk. For most tasks, a well-designed custom GPT (no autonomy) is safer and more reliable than an agent (autonomous actions).
- “Building a GPT requires coding” — Zero code required. The collection was built entirely through the GPT Builder interface with natural language instructions.
Custom GPTs for YOUR Field
- Patient FAQ GPT: Loaded with your clinic’s policies, hours, insurance info, and common questions. Reduces front desk call volume.
- Discharge Instructions GPT: Generates personalized post-visit care instructions from structured inputs. Nurse reviews before giving to patient.
- Continuing Education GPT: Loaded with latest clinical guidelines, quizzes staff on protocol updates.
- Customer Service GPT: Trained on your product catalog, return policy, and FAQ. Handles first-line inquiries, escalates complex issues.
- Onboarding GPT: New hire guide loaded with company handbook, benefits info, and role-specific training materials.
- Sales Prep GPT: Loaded with competitor data and product specs. Sales reps ask questions before client meetings.
- Course Tutor GPT: The ELEVATE model — loaded with textbook and answer keys, guided by the 7-step tutoring algorithm.
- Syllabus GPT: Answers “when is the exam?” and “what’s the late policy?” so you don’t have to.
- Assignment-Specific GPT: One per homework, loaded only with relevant chapter content. Prevents scope creep.
- Policy FAQ GPT: Loaded with department regulations and procedures. Citizens and staff get instant answers to policy questions.
- Grant Writing GPT: Loaded with RFP requirements and successful past proposals. Guides applicants through the process.
- Compliance GPT: Tracks regulatory requirements and helps staff determine if their activities are compliant.
Building Custom GPTs: Step by Step
A custom GPT is a personalized version of ChatGPT with three components:
- Instructions — what it should do, how it should behave, what it should avoid
- Knowledge — uploaded files it can reference (PDFs, docs, data)
- Settings — whether it can search the web, generate images, run code
Step 1: Define the Purpose (5 minutes)
Before you build anything, answer these questions:
- Who is this for? (Students? Customers? Your team? Yourself?)
- What problem does it solve? (Tutoring? FAQ? Drafting? Analysis?)
- What should it NEVER do? (Give final answers without explanation? Access data it shouldn’t? Pretend to be human?)
Step 2: Write the System Instructions (15-30 minutes)
The system instructions are the soul of your custom GPT. This is where the ELEVATE project’s 7-step tutoring algorithm lives:
“I want you to adopt the persona of a supportive tutor who encourages a step-by-step approach to solving statistics problems. When I provide a question, first restate it and confirm that you’ve understood. Then offer relevant resources (theorems, definitions, textbook sections, or sample exercises), and ask if I’m familiar with them. Prompt me to share my initial approach, validate correct reasoning, clarify misconceptions, and guide me toward the next step. If I struggle, ask whether I’d like a hint or an example. If I request the entire solution, gently encourage a step-by-step effort. Should I deviate from this incremental reasoning style or fail to provide a question, respond with a brief suggestion to reformat or clarify. Otherwise, keep your guiding statements to a few sentences and hints, not entire solutions. When all else fails, reveal only the first step and prompt me to proceed. After completion, summarize the key lessons and reinforce the textbook concepts before asking if I have further questions. Now please wait for me to ask the question.”
This prompt solves two problems simultaneously: instructional consistency (every student gets the same scaffolded experience) and knowledge grounding (the GPT references the uploaded textbook, not random internet content).
Step 3: Upload Knowledge Files (10 minutes)
Upload the documents your GPT should reference:
- Course textbook or manual
- Answer keys and worked examples
- Policy documents and FAQs
- Relevant data files or templates
- Style guides or brand guidelines
The GPT will search these files when answering questions, grounding its responses in YOUR content rather than its general training data. This dramatically reduces hallucinations for domain-specific questions.
Step 4: Configure Settings (2 minutes)
- Web search: Enable if the GPT needs current information. Disable if you want it to stay within your uploaded knowledge.
- Image generation: Enable for creative tasks. Disable for academic/professional GPTs where images aren’t relevant.
- Code interpreter: Enable if users will work with data, code, or calculations.
Step 5: Test and Iterate (20+ minutes)
This is where most people stop too early. Test your GPT with:
- Happy path: The exact type of question it’s designed for. Does it respond well?
- Edge cases: Unusual or ambiguous questions. Does it handle them gracefully?
- Adversarial inputs: What happens if someone asks it to do something outside its scope? Does it stay on task?
- Knowledge boundary: Ask something NOT in your uploaded files. Does it say “I don’t see this in my materials” or does it hallucinate?
Iterate on the system instructions until the GPT consistently behaves the way you want.
Custom GPTs in Practice: The ELEVATE Collection
Here are real custom GPTs built and deployed for the ELEVATE project, with their actual purposes:
| GPT | Purpose | Key Design Choice |
|---|---|---|
| MATH 3200 Syllabus GPT | Answers policy and logistics questions | Knowledge: syllabus PDF. Reduces “when is the exam?” emails to zero. |
| Chapter 1-4 Tutors | Topic-specific guided learning | Each loaded with ONLY that chapter’s content. Prevents scope creep. |
| Exam Review Bot | Structured exam preparation | Generates practice problems, then walks through solutions step by step. |
| R Tutor for MATH 2200 | Coding help aligned to course tools | Trained on mosaic package and course-approved R functions only. Won’t suggest packages students haven’t learned. |
| DOE Assistant | Design of Experiments guidance | Loaded with experimental design materials. Helps students design their own studies. |
The Review Protocol: How to Verify Student AI Use
When students submit work done with custom GPTs, the professor reviews:
- The shared conversation link — students click “Share” in ChatGPT and submit the full transcript
- The student’s own work — their final answer, calculations, or write-up alongside the transcript
- Evidence of reasoning — did they revise or challenge the AI’s suggestions, or just copy?
- SMARTS process — did they follow State → Map → Ask → Reason → Think → Summarize?
This transparency protocol solves the academic integrity problem without banning AI. The AI is a tool; the transcript is proof of how it was used.
You want to build a GPT for new employee onboarding at your organization. Quick quiz:
- What files would you upload? (Employee handbook, benefits guide, org chart, FAQ document, role-specific training materials)
- What should it NEVER do? (Give legal advice, access employee records, make promises about benefits that aren’t in the documents)
- Why would you disable web search? (To keep answers grounded in YOUR documents — you want it answering from company policy, not random internet content)
Workflow Automation: Beyond Custom GPTs
Custom GPTs handle conversations. Automation tools handle workflows — connecting apps, triggering actions, and processing data without human intervention.
What Automation Looks Like
Without automation: You receive an email with a PDF invoice. You open it, manually enter the amounts into a spreadsheet, categorize the expense, and email the accounting team.
With automation: The email arrives. An automation tool detects the PDF attachment, extracts the amounts using AI, adds them to your spreadsheet, categorizes the expense based on the vendor name, and sends a summary to accounting. You do nothing.
No-Code Automation Tools
| Tool | What It Does | Complexity | Cost |
|---|---|---|---|
| Zapier | Connects 6,000+ apps with if-then logic + AI | Low-medium | Free tier + paid |
| Make (Integromat) | Visual workflow builder, more complex logic | Medium | Free tier + paid |
| Microsoft Power Automate | Deep Microsoft 365 integration | Medium | Included with M365 |
| n8n | Open-source, self-hosted, maximum control | Medium-high | Free (self-hosted) |
| Apple Shortcuts | On-device automation for Apple users | Low | Free |
Common Automations Worth Building
- Email → Summary → Task: When you receive an email longer than 200 words, AI summarizes it and creates a task in your to-do app
- Meeting → Transcript → Action Items: After a Zoom meeting, AI transcribes it and extracts action items
- Form → Data → Report: When someone submits a form, AI processes the data and generates a weekly summary report
- New Article → Summary → Notification: When a key publication posts a new article, AI summarizes it and sends you a notification
The Autonomy Spectrum
Not every automation should run without oversight:
| Autonomy Level | Example | When to Use |
|---|---|---|
| Fully automated | Spam filtering, data backup, format conversion | Low-stakes, reversible, well-understood tasks |
| Automated + notification | AI categorizes expenses and notifies you of the result | Medium-stakes, where you want visibility but not manual effort |
| Automated + approval | AI drafts a response and waits for you to approve before sending | High-stakes communication, financial transactions |
| Human-initiated | You trigger the automation manually when needed | Tasks that require judgment about WHEN to run |
In November 2022, Jake Moffatt’s grandmother died. Needing to fly from Vancouver to Toronto for the funeral, Moffatt visited Air Canada’s website and asked its chatbot about bereavement fares. The chatbot said they could apply for the reduced fare retroactively, within 90 days of travel. That was wrong — Air Canada’s actual policy required applying before travel.
Moffatt booked a full-fare ticket, flew, and submitted the retroactive application. Air Canada denied it and argued in tribunal that the chatbot was “a separate legal entity that is responsible for its own actions.” The British Columbia Civil Resolution Tribunal rejected this argument: “It should be obvious to Air Canada that it is responsible for all the information on its website.” Air Canada was ordered to pay damages (Moffatt, 2024 BCCRT 149).
The lesson: If you deploy a customer-facing agent at your organization — whether it’s a Custom GPT, a Claude Project, or a Zapier automation — you own what it says. The guardrail principle isn’t optional. It’s legal liability.
An agent is only as good as the guardrails you give it. The skill isn’t building the agent — it’s knowing when to let it run and when to step in. Automate the boring. Supervise the important. If a mistake would be embarrassing, costly, or irreversible, add a human approval step.
When to Use What: A Decision Framework
Do I need AI to have a CONVERSATION?
├── YES → Custom GPT (with instructions + knowledge)
│ └── Does it need to take ACTIONS (send emails, update databases)?
│ ├── YES → Full AI Agent (GPT Actions, Claude MCP, etc.)
│ └── NO → Custom GPT is sufficient
└── NO → Do I need to AUTOMATE a repeated workflow?
├── YES → Automation tool (Zapier, Make, Power Automate)
│ └── Does it need AI to UNDERSTAND content (not just route it)?
│ ├── YES → Automation + AI (Zapier AI, Make AI node)
│ └── NO → Simple automation (no AI needed)
└── NO → You probably just need a regular prompt (Modules 4-6)Guided Practices
Pick ONE task from your real work or studies. Design (don’t build yet — just plan) a custom GPT for it:
- Purpose: What does this GPT do? (one sentence)
- System instructions: Write 5-7 rules it should follow. Include at least one constraint (what it should NOT do).
- Knowledge files: What documents would you upload? (list 2-3)
- Test prompts: Write 3 prompts a real user would send. For each, describe what a GOOD response looks like and what a BAD response looks like.
- Autonomy level: Where does this sit on the spectrum — fully automated, automated with notification, automated with approval, or human-initiated? Why?
Example: Course FAQ GPT
Purpose: Answer student questions about MATH 2200 using only the syllabus and course materials.
Rules: (1) Only answer from uploaded files. (2) If the answer isn’t in the files, say so and direct to the professor. (3) Never give exam answers. (4) Be encouraging but honest. (5) Keep responses under 100 words.
Knowledge files: Syllabus, assignment descriptions, grading rubric.
Test prompts: “When is the midterm?” (should find exact date), “What’s the answer to homework 3?” (should refuse), “Can I use a calculator on exams?” (should check syllabus and answer).
Autonomy: Human-initiated. Low stakes — wrong FAQ answer is inconvenient, not harmful.List 5 repetitive tasks you do every week. For each:
- How long does it take?
- Could any part be automated? (Which tool — Zapier, AI, spreadsheet formula, or none?)
- What’s the risk if the automation makes an error?
- Verdict: automate, partially automate, or keep manual?
Total up the time you’d save. Is the setup effort worth it?
Module 8 Summary
Chatbots react. Agents act. Custom GPTs sit in the middle — persistent instructions and knowledge, but no autonomous actions.
Building a custom GPT takes 30-60 minutes: define purpose → write system instructions → upload knowledge → configure settings → test extensively → share.
The ELEVATE tutoring prompt solves instructional consistency AND knowledge grounding simultaneously. The 7-step algorithm guides without giving away answers.
The transcript review protocol — shared conversation links + student’s own work — solves academic integrity without banning AI.
The MATH 3200 experiment showed the AI section (72.20) outperformed the traditional section (68.20). This isn’t theory — it’s measured.
Automation tools (Zapier, Make, Power Automate) handle workflows, not conversations. Use them for connecting apps and processing data.
The autonomy spectrum: fully automated → automated + notification → automated + approval → human-initiated. Match the autonomy level to the stakes.
Automate the boring. Supervise the important. If a mistake would be embarrassing, costly, or irreversible, add a human checkpoint.
The professor who deleted his slides wasn’t being reckless. He was asking a question that most institutions are afraid to ask: what if the AI version is actually better? His data says the AI section outperformed the traditional one. His students said the custom GPTs were helpful. His transcripts showed students reasoning through problems instead of copying answers. The experiment didn’t prove AI is always better. It proved that well-designed AI integration, with the right guardrails and the right pedagogy, can outperform the status quo. The key phrase is “well-designed.” A bad custom GPT is worse than no GPT at all. The design is everything.
🔬 Lab 8: The Automation Sprint
Lab 8: Build Your Own Custom GPT
Time: 60 minutes | Tools needed: ChatGPT Plus or Teams account (for GPT Builder), OR Claude Projects, OR any platform with custom assistant features
Part A — Design (15 min) 1. Choose a real use case from your work, studies, or personal life. 2. Write out: Who is this for? What problem does it solve? What should it NEVER do? 3. Draft your system instructions (use the ELEVATE tutoring prompt as a model if relevant).
Part B — Build (20 min) 4. Create the custom GPT using your platform’s builder. 5. Upload 2-3 relevant knowledge files (a syllabus, a manual, a guide, sample data). 6. Configure settings (web search on/off, code interpreter on/off).
Part C — Test (15 min) 7. Test with 5 different inputs: - 2 typical use cases (happy path) - 1 edge case (unusual question) - 1 out-of-scope question (should it decline or redirect?) - 1 knowledge boundary test (ask about something NOT in your uploaded files) 8. Rate each response: On-task? Accurate? Helpful? Appropriately bounded?
Part D — Reflection (10 min) 9. What worked well? What needs iteration? How would you improve the system instructions? How long did this take vs. how much time will it save over the next semester/quarter?
Submit: Your system instructions, test results table, and reflection.
🎮 Module 8 Quiz
Previous: Module 07 — Multimodal AI | Next: Module 09 — AI Infrastructure