Workshop 5: Getting Started with Agentic AI
Workshop 5: Getting Started with Agentic AI
From chatbots to assistants that take steps — agents, instructions, and skills
Upcoming — Fall 2026 | Date TBD | 1 hour | Bring a laptop
This is an intro-level session planned for the fall. No coding required. The date will be posted on the home page once scheduled. The agenda below is a draft. It builds on the shared Projects and custom GPTs from Workshop 3.
What You’ll Leave With
By the end of this hour, you will be able to:
- Explain in plain terms what “agentic” AI means and how it differs from a normal chat
- Name the building blocks of an AI assistant: instructions, knowledge, tools, and skills
- Set up a simple assistant in ChatGPT Edu with clear instructions and a knowledge file
- Write a reusable “skill”—a packaged set of instructions for a task you repeat
- Apply basic guardrails: keep a human in the loop and know the data rules
- Recognize automation bias and decide when a task should not be handed to an agent
Run of Show
| Time | Segment |
|---|---|
| 0:00–0:10 | Overview: what “agentic” means and the four building blocks |
| 0:10–0:25 | Ethics & Governance: automation bias, oversight, and when not to automate |
| 0:25–0:42 | Activity 1: Set up your first assistant (instructions + knowledge) |
| 0:42–0:55 | Activity 2: Write a reusable skill and run a multi-step task |
| 0:55–1:00 | Wrap-up: guardrails, data rules, and where to go next |
Overview (10 min)
From answering to doing. A normal chat answers one prompt at a time—you steer every step. An agentic workflow is one where you give the AI a goal and some standing guidance, and it plans and carries out several steps toward that goal, using files or tools along the way, checking in with you as needed. The difference is less “answer my question” and more “handle this task, and show me your work.”
The four building blocks. Every assistant or agent, in any tool, is some combination of:
- Instructions — the standing guidance: who it is, how it should behave, the format and tone it always uses. This is where most of the quality comes from.
- Knowledge — files or context you give it to work from (a template, a style guide, a reference document).
- Tools — things it can actually do beyond writing text: search the web, read a document, run a step. (In ChatGPT, “agent mode” and connected actions; admin-controlled in the Drexel workspace.)
- Skills — reusable, packaged instructions for a specific repeatable task, so you don’t rebuild the same setup each time.
A skill is a saved package of instructions (and sometimes example files) that tells an assistant how to do one job well—like “turn meeting notes into our standard recap format.” You write it once; the assistant uses it whenever that job comes up. Claude has a formal feature literally called Skills. In ChatGPT Edu, you get the same effect with custom GPTs, project instructions, and saved instruction blocks. The idea is the same everywhere: capture the know-how once, reuse it.
This works across tools. We’ll do hands-on in ChatGPT Edu because it’s approved for Drexel data. The concepts—instructions, knowledge, tools, skills—are the same in Copilot and Claude. For the most advanced agentic features and the formal Skills system, see the Claude note at the end (PI-paid, and not for Drexel data).
Ethics & Governance: Automation Bias, Oversight, and When Not to Automate (15 min)
The thread concludes here. Earlier workshops asked what AI writes and how teams share it. Once AI starts to act—taking steps on its own—the central question becomes oversight: how much do you hand off, and how do you stay responsible for it?
Responsibility doesn’t transfer. An agent can plan and carry out a series of steps, but you still own the outcome. More autonomy for the tool does not mean less responsibility for you—if anything, it means you have to be more deliberate about where you let it run.
Automation bias is the core risk. People over-trust automated output, especially when it’s fast and stated with confidence, and quietly stop checking. Agentic workflows make this sharper: when an agent chains several steps, a small error early on compounds through everything after it. The countermeasure is unglamorous—review each step, not just the final result, and stay skeptical exactly when the output looks polished.
The black-box problem. You often can’t see why an agent chose a step. If you can’t explain or justify what it did, don’t act on it for anything that matters. “The agent decided” is not a defensible reason for a consequential decision.
When not to automate. Keep agents on low-stakes, reversible, checkable work. Do not hand off high-stakes or irreversible decisions, anything affecting a person’s care, benefits, eligibility, or rights, anything involving regulated data, or anything you couldn’t verify afterward. Those stay with a human—full stop.
Oversight as governance. Start small, keep a human approval step before anything consequential happens, document where agents are used in real work, and confirm Drexel’s data classification before an agent touches real data. This is the same accountability principle from Workshop 1, now applied to a tool that can take action on its own.
Three questions before handing a task to an agent: Reversible? (could I undo a wrong result). Verifiable? (can I check each step). Low-stakes? (no one’s care, rights, or benefits ride on it). If any answer is no, keep a human doing it.
Activity 1: Set Up Your First Assistant
Activity 1: Set Up Your First Assistant
Goal: Build a working assistant by writing good instructions and giving it knowledge—the core of every agent.
Instructions
- In ChatGPT Edu, create a custom GPT (or a Project, from Workshop 3) for a real task you repeat. Examples: “Plain-Language Rewriter,” “Grant Deadline Checker,” “Standard Meeting Recap.”
- Write clear instructions. Cover four things:
- Role: who it is (“You are a writing assistant for the DSPH [team]”).
- Behavior: how it works (“Always ask for the audience before drafting”).
- Format: what its output looks like (“Return a title, 3 bullets, and a one-line bottom line”).
- Limits: what it must not do (“Never include identifying or sensitive data; flag anything that needs a human decision”).
- Add one knowledge file that is appropriate under Drexel’s Terms of Use—a template, a style guide, a sample of the format you want. No PHI, sensitive PII, confidential HR or contract material, or identifiable research data.
- Test it with two different inputs. Where it drifts from what you wanted, tighten the instructions and try again. Notice that better instructions—not a longer prompt—fix most problems.
Reflection
- Which instruction made the biggest difference to the output?
- What did you have to spell out that you assumed it would “just know”?
Activity 2: Write a Skill and Run a Multi-Step Task
Activity 2: Write a Skill and Run a Multi-Step Task
Goal: Turn your setup into a reusable skill, and see an assistant carry out a task with more than one step.
Part A — Write a Reusable Skill (~9 min)
Capture the instructions from Activity 1 as a standalone skill you could reuse or hand to a colleague. A good skill states the job, the steps, the output, and the guardrails:
Skill: Standard Meeting Recap When to use: After any team meeting with notes. Steps: (1) Read the notes. (2) Produce a 3-bullet summary. (3) List decisions. (4) List action items as a table with owner and due date. (5) Flag anything unassigned or unclear. Output: Three labeled sections, plain language, under 250 words. Guardrails: No sensitive or identifying data. If notes are missing an owner or date, ask before finishing.
Save it where your team can find it (a shared doc, a Project, or a custom GPT’s instructions). That’s the reusable part—next time, you don’t rebuild it.
Part B — Run a Multi-Step Task (~9 min)
- Give your assistant a small task that takes more than one step—for example: “Read the uploaded report, pull out the three key findings, then draft a short email to my team about what they need to do.”
- If agent mode is enabled in your Drexel workspace, try a goal that involves the assistant looking something up or working through steps, and watch how it plans and pauses.
- Review every step. Don’t accept the final output blind—check that each step did what you intended. The human-in-the-loop is the point.
Discussion
- Where would a reusable skill save your team the most repeated effort?
- For a multi-step task, where would you want the assistant to stop and check with you before continuing?
Wrap-Up (5 min)
- Agentic means giving the AI a goal and standing guidance, and letting it carry out steps—with you reviewing.
- The building blocks are instructions, knowledge, tools, and skills. Most of the quality is in the instructions.
- A skill captures the know-how for a repeated task once, so you and your team reuse it.
- Guardrails matter: keep a human in the loop, review each step, and never put data into a tool that isn’t approved for that classification.
The more an assistant does on its own, the more its mistakes can compound. Start small, review each step, and keep agentic tasks to low-stakes work until you trust the setup. Confirm data classification on Drexel’s AI Tools page before any agent touches real documents.
For the most developed agentic features—a formal Skills system, Projects, and MCP connections to outside tools and data sources—Claude is the strongest option, and some PIs license it themselves. It is not approved for Drexel data: use it only with public or fully synthetic information. The concepts you practiced today transfer directly. See Tools & Access.