6 Agentic AI

From Chatbot to Agent

The preceding chapters focused on conversations with AI. You wrote a prompt, reviewed the response, added context, and prompted again. Those skills still apply. Agentic tools change who chooses some of the steps between the request and the result.

Anthropic’s engineering guide draws a useful distinction between workflows, where tools follow a predefined path, and agents, where the model directs more of the process and tool use. A simple agent loop looks like this:

1. Receive a goal and approved context.
2. Choose an action or tool.
3. Observe what happened.
4. Continue, ask for help, stop, or return control.

Actual systems vary. This loop describes visible behavior that faculty can supervise. It does not claim to reveal a universal internal reasoning process.

The same language model may support all three forms. What changes is the environment around the model: the files and tools it can reach, the actions it can take, the feedback it receives, and the amount of discretion a person grants it. A regular chat may become more agentic when it can search the web, operate a browser, edit files, run code, or work in the background.

Faculty now encounter agentic behavior in research tools, browser assistants, connected productivity systems, and file or software workspaces. Product labels and features change quickly. The durable questions concern the task: Who chooses the next step? What can the system see and do? What result comes back? When does a person review or redirect the process?

What Agentic Tools Look Like in Practice

Deep Research

Deep research tools offer a concrete introduction to agentic behavior. A person asks a research question, and the system breaks the question into searches, opens sources, revises its search strategy, and produces a report with links or citations. The person does not direct every search query.

This is a narrow agent because it specializes in one kind of task. Its source links make the process easier to inspect, although source grounding does not establish that every claim is accurate or well supported. Evaluating AI Outputs and Interactions explains how to check the report’s claims, sources, and fit.

Browser Assistants

A browser assistant can work with webpages instead of only discussing them. Depending on the product and permissions, it may inspect open pages, follow links, click controls, enter text, and move information between sites. A faculty member could ask one to compare public program descriptions across several pages or organize open educational resources into a table.

Browser access also raises the stakes. A browser may contain email, student records, grades, saved credentials, or forms that create an external action. Begin with public information and read-only tasks. Keep the assistant away from live institutional systems until the institution has approved the product and the specific use.

Productivity Suite Agents

Agentic features also appear inside document, spreadsheet, presentation, email, and meeting platforms. These systems can work from materials already present in the suite and may complete a sequence such as turning notes into a document, organizing a spreadsheet, or preparing a presentation for review.

Faculty may recognize this pattern because the agent appears inside an existing work platform. Access depends on the institution’s agreements and settings. Check which data the feature can reach, where the result is stored, and whether the system proposes changes or applies them.

Agentic Workspaces for Knowledge Work

Some current tools began as command-line agents. A terminal is a text-based window for interacting with a computer. At its command line, a person types instructions that a program executes. A command-line agent is an AI tool that works through that interface. A person points it toward a folder or project and assigns a job. The agent can inspect files, create or edit files, run checks, and report what changed.

Claude Code and OpenAI Codex are coding agents that began in software development. Software gives an agent concrete materials to inspect, edit, run, and test. Both tools now have interfaces beyond the terminal, but their basic pattern remains useful for understanding agentic work. In this chapter, a workspace means the files and tools made available for a particular task. A chatbot usually returns its work inside a conversation. A workspace agent can return changed files, a tested website, a reorganized folder, or another artifact that exists outside the chat.

That pattern can support knowledge work when the workspace contains course materials or research rather than a software project. A course folder, a collection of PDFs, a Pressbooks chapter, or a meeting transcript gives the agent something concrete to inspect. The result might be a reading matrix, a cleaned file set, a class review sheet, an accessibility log, or a small interactive activity.

Claude Cowork brings file and connected-tool work into a desktop interface designed for broader tasks. The user chooses the folders and tools it may access, gives it an outcome, and reviews the result. Google Antigravity remains developer-oriented but works similarly to Claude Code and Cowork. Google currently describes Antigravity 2.0 as a desktop application for orchestrating multiple agents and also offers a separate command-line interface. These products differ in audience and interface, but each goes beyond a stand-alone chatbot by acting on materials in an approved work environment.

Faculty accounts make those possibilities concrete. Lance Eaton describes using Codex, Claude Code, and Cowork to organize downloads, rename and classify research PDFs, sample a large source collection before sorting the rest, build small personal tools, and analyze course materials. Stefan Bauschard describes creating Word documents, slide decks, spreadsheets, PDFs, class-session review sheets, and weekday briefings.

Marc Watkins offers several teaching examples. In “The Fable of AI in Education”, he describes small tools for communicating AI expectations, tracking reading and reflection, and creating interactive activities around literary texts. In “Context Is All You Need”, he describes adapting an in-person reflection activity for online students, prototyping a live-poll tool, and creating a gallery where visitors could compare projects and leave feedback. These examples begin with the instructor’s learning goal, source materials, and design judgment. The agent builds a prototype that the instructor still has to inspect and revise.

Ruben Hassid’s introduction to vibecoding gives nontechnical users a starting process for building clickable mockups and small tools from plain-language instructions. Begin with a clean folder, describe the intended result, work in small pieces, inspect what the agent built, and revise in short cycles. Use the article’s early prototyping advice only. Its recommendations to bypass permission prompts or connect deployment and database services fall outside this activity’s boundaries. Access remains uneven. Paid plans, usage limits, software-installation rules, and institutional policies may determine which route a faculty member can use.

What Steers an Agentic Workspace

A substantial agentic task depends on more than one clever prompt. The model works inside an application or workspace that supplies context, tools, permissions, and feedback. Technical teams sometimes call that surrounding environment an agent harness. Faculty do not need to configure one to understand the practical controls around the work.

Some platforms store project instructions in a project setting or a small file associated with a workspace. Some also let people reuse saved methods or connect the agent to outside services. An application programming interface (API) is a defined way for software systems to communicate. The Model Context Protocol (MCP) is an open standard that gives AI applications a consistent way to connect with external tools and data.

Faculty do not need to build these connections themselves. The practical questions are what a connection exposes, what actions it permits, and whether the institution has approved that use.

Instructions and permissions are separate controls. A written instruction such as “do not publish” guides the agent’s behavior. Withholding publication access creates a stronger boundary because the system cannot take that action if it misinterprets the instructions or encounters conflicting directions.

Speed can also create maintenance debt. An agent may produce a working website, revised course unit, or elaborate automation faster than a faculty member can inspect or maintain it. Before using the artifact, the faculty member should be able to explain its purpose, identify its source materials, restore an earlier version, and determine who will maintain it.

Good first agentic tasks are bounded, reversible, and inspectable. Examples include producing a source-linked research brief, checking copied course materials for stale links, identifying possible accessibility problems, or creating a private prototype of one learning activity. Grading student work, communicating with students, changing a live course, or publishing materials require stronger institutional review and tighter controls.

A Fifteen-Minute First Experiment

Getting started does not require project-instruction files, reusable skills, APIs, or programming knowledge. Choose an agentic platform available through your institution or personal account, install or open its desktop application, and create a clean folder containing a few non-sensitive, instructor-created course materials. Give the agent access only to that folder and assign one exploratory task.

For example, Claude Cowork runs through the Claude desktop application and can work with a folder selected by the user. Other agentic workspaces follow a similar pattern. The product and interface matter less than the sequence.

A first prompt can be exploratory without giving the system broad authority:

Using only the materials in this folder, propose three useful things you could create for this course. Focus on small artifacts that would help students understand or practice the material. Do not change the original files, connect to outside services, or publish anything. Explain each option briefly, then wait for me to choose one.

After choosing an option, the faculty member might continue:

Create a private, one-page teaching website based on the materials in this folder. Include a short overview, one comparison activity, and three reflection questions. Before building, show me your plan and wait for approval. Do not add accounts, collect user data, connect outside services, or publish the result.

This experiment shows the difference between asking a chatbot to describe an artifact and giving an agent a folder, a finish line, and permission to produce a working draft. The folder should contain copies rather than irreplaceable originals. The experiment should end with a private result the faculty member can inspect, revise, or discard.

Ancillaries That Extend the Course

Faculty who prefer to write their own assignments, explanations, and other core course materials may still find agentic AI useful. An agent can work from instructor-authored content to create a labeled visual, an HTML walkthrough designed for accessibility, an interactive practice activity, a complex diagram, an alternate format, or a companion website. These ancillaries build around the instructor’s course while leaving its intellectual core in faculty hands.

A faculty member might ask a chatbot to draft a handout, summarize a reading, or revise an announcement. The chatbot attempts to complete the same task faster. Agentic AI can also help an instructor prototype a resource that would ordinarily require substantial coding, web-design, illustration, or media-production time.

In philosophy, an instructor might turn an instructor-created comparison table into an interactive concept map. A nursing instructor might build a step-by-step HTML walkthrough from approved course language and images. Mathematics faculty might create a visual demonstration that lets students change one variable and observe what happens to another. A history instructor might convert a collection of primary sources into a private timeline prototype with filters and contextual notes.

Sarah, for example, keeps her reading, assignment, and explanations as she wrote them. She places copies in a clean folder and asks an agent to create an interactive comparison activity based on those materials. The agent builds the initial HTML, layout, and controls and reports the tests it ran. Sarah checks every explanation, tests the activity with a keyboard and small screen, and decides whether the interaction helps students practice the intended skill.

The faculty member remains responsible for disciplinary accuracy, accessibility, privacy, and learning design. Agent-generated ancillaries can contain errors, introduce inaccessible interactions, or add features the instructor never requested. The same limits still apply: work from copies, limit access, keep the first version private, and review the artifact before students encounter it.

Try This: Build a Small Teaching Website

Choose an agentic builder, a tool that turns plain-language instructions into a working prototype. Google AI Studio’s Build mode runs in a browser and creates a live preview. Google Antigravity, Claude Code, and OpenAI Codex are developer-oriented coding agents or platforms that can create and test website files. Claude Cowork is a broader workspace agent that can act on files and produce artifacts. Plans, account eligibility, downloads, institutional access, and usage limits vary.

If you do not have access to an agentic builder, use a general-purpose chatbot for the planning route. Give it the same website brief and ask it to propose a one-page storyboard showing the sections, instructions, interactions, and expected student experience. Inspect the plan, revise it through conversation, and identify what a working prototype would still need.

Use one of Marc Watkins’s teaching prototypes as a starting pattern. Adapt a reflection activity for online students, create a non-networked mockup of a live poll, or design a gallery where students can compare examples and leave notes stored only for that browser session. You can also choose another small need from your own course.

Keep the first version to one page. Use public, openly licensed, or instructor-created sample content. Leave out student data, logins, databases, analytics, external services, and live institutional systems. Keep the prototype private while you inspect and revise it.

Here, private means unpublished. It does not establish that the prototype is local or confidential. Test forms only with invented text. If the builder adds a login, saves user entries after the browser closes, or sends information to another online service, remove that feature or use the storyboard route.

Use this prompt as a starting point:

I teach [subject] at the [introductory/intermediate/advanced] level. Build a private, one-page website prototype for [students or faculty] that helps them [complete one specific learning activity]. Use only the sample content I provide. Include [two or three features, such as a short reading, comparison activity, reflection box, quiz, or downloadable summary]. Do not add accounts, stored user data, tracking, connections to other online services, or a publication step. Use only invented text to test anything a user can enter. Before building, ask me up to three questions about the audience, learning goal, and desired interaction. Then summarize your plan, list the files and tools you expect to use, and wait for my approval. After I approve, build and test the page. Report what changed and what I should review for accuracy, accessibility, privacy, mobile use, and fit with the learning goal.

Review the first version in two passes. Start with the learning design. Decide whether the interaction helps learners practice the intended skill and preserves the thinking you want them to do. Then check the experience. Read every instruction, move through the page with a keyboard, test it on a small screen, and inspect anything the page asks a user to enter. Ask the agent to revise after each review.

Stop with a working private draft or a complete storyboard. Use the page map, change-and-test record when available, and your immediate review to identify what you would verify or change before students use the activity.

Looking Ahead

This activity applied the chapter’s central pattern: define the task, limit the system, inspect what happened, and decide what still needs review.

Evaluating AI Outputs and Interactions asks a different set of questions about the result. Its ABC checks examine claims and evidence, bias and perspective, and contextual fit. A well-controlled process can still produce a weak or inaccurate artifact. Responsible Use in Education then considers whether the tool, information, and intended use were permissible and who remains accountable.

The sequence is straightforward. Prompting for Educators defines the work. Agentic AI controls the delegated process. Evaluating AI Outputs and Interactions evaluates the result. Responsible Use in Education judges whether the workflow should be used.

References

Anthropic. (2024, December 19). Building effective agents.

Anthropic. (n.d.). Claude Code.

Anthropic. (n.d.). Claude Cowork.

Bauschard, S. (2026, June 7). 12 ways I use Claude, including CoWork and Code. Education Disrupted.

Eaton, L. (n.d.). Exploring agentic AI. AI Education Simplified.

Google. (2026, May 19). Building the agentic future: Developer highlights from I/O 2026.

Google AI for Developers. (2026). Build apps in Google AI Studio.

Hassid, R. (n.d.). Vibecoding.

Model Context Protocol. (n.d.). What is the Model Context Protocol?

OpenAI. (n.d.). Codex.

Watkins, M. (2026). Context is all you need.

Watkins, M. (2026). The fable of AI in education.

Further Reading

• Anna Mills, “Should Educators Use Agentic AI? If So, How?” considers early faculty experiments and institutional boundaries.
• Liza Long, “Accessibility by Design” and the Idaho State Board of Education’s Artificial Intelligence and Accessibility provide examples of bounded accessibility work with AI.
• Leon Furze, “A Taxonomy of Agentic AI” and Mike Taylor, “Where Do You Fall on the Eight Levels of AI Adoption?” offer practitioner maps of current tools and adoption. Treat these as dated orientation rather than required progress ladders.