---
# System prepended metadata

title: bok-ai-lab-20250425-glossary

---

# bok-ai-lab-20250425-glossary

### Agent

An agent is a software system that can take in information from its environment, make decisions, and act toward a goal—often with minimal human intervention. In educational AI settings, an agent might read a prompt, decide to look up a source, summarize it, and send the output to Slack—all without being explicitly told to perform each step. What distinguishes agents from traditional scripts or apps is their sense of **initiative and adaptability**: they don’t just follow commands—they interpret goals and figure out how to get there, often using large language models to reason, plan, or select tools in context. While not sentient, agents can feel like intelligent collaborators capable of carrying out meaningful portions of human work.


---


### Agentic Workflow

An agentic workflow is a **structured process that simulates human-like autonomy**, typically by breaking down a goal into a sequence of steps that a machine can complete—sometimes automatically, sometimes with human input. These workflows might not involve a “true agent,” but they feel agentic: for instance, a Slack message triggers a transcription, which triggers a summary, which updates a document. Agentic workflows are common in teaching and research when LLMs are embedded into daily tasks. They’re particularly valuable for educators because they **amplify capacity** without requiring full automation—offering structured assistance while keeping instructors in control.


---


### Autonomy

Autonomy refers to an agent’s ability to **decide what to do and when to do it**, without waiting for detailed instructions. In fully autonomous systems, the agent can interpret high-level goals (e.g., “create a study guide from this lecture”) and pursue them through a series of self-directed actions, including using tools, revising plans, or asking clarifying questions. Autonomy can exist on a spectrum—from basic (choosing which prompt to run next) to complex (managing long-term tasks over hours or days). In classrooms, partial autonomy is often preferred: agents act independently on well-scoped tasks, but pause for human oversight when ambiguity or risk increases.


---


### Tool Use

Tool use is the defining feature of agentic systems: it allows an AI to **go beyond language generation** and interact with real-world systems, from web searches to spreadsheets, APIs, or Slack channels. Most LLM-based agents don’t store knowledge in a database—they “think out loud” and rely on tool calls to retrieve, calculate, or update external information. Tool use is often facilitated by “function calling” frameworks that allow an LLM to decide, in the middle of a conversation, to trigger a specific tool. In educational workflows, this might mean an agent that checks a syllabus, fetches a grading rubric, or posts updates based on a transcription pipeline—all through tool integrations.


---


### Planning

Planning is the agent’s ability to **break down a complex goal into smaller, executable parts**, and figure out a sequence of actions to complete them. In human terms, it’s what allows us to say: “First I’ll outline the paper, then I’ll find sources, then I’ll write a draft.” In AI agents, planning often occurs through recursive prompting or via a planning module: the agent begins by drafting a plan (e.g., “Step 1: Transcribe; Step 2: Summarize; Step 3: Generate Q&A”) and then executes each step in turn. Planning makes agents feel deliberate rather than reactive—and is essential for chaining tools or actions across time.


---


### Memory

Memory allows agents to **retain information across interactions**, improving their coherence, personalization, and capacity for long-term reasoning. This might include remembering prior steps in a workflow (“we’ve already summarized this transcript”), tracking user preferences, or maintaining project history. Memory can be short-term (limited to the current session), long-term (stored in vector databases or custom logs), or dynamic (recalled when contextually relevant). In education, memory-enabled agents might recall prior classroom topics, student questions, or frequently asked queries—providing continuity that static tools can’t match.


---


### Multi-Agent System

A multi-agent system (MAS) involves **several agents working in coordination**, each with distinct roles, capabilities, or goals. These systems can model teams, debates, or collaborative workflows—where one agent gathers data, another critiques, and another synthesizes. Multi-agent frameworks are increasingly used in generative AI, with agents “talking to each other” to solve problems, evaluate outputs, or simulate complex scenarios. In academic contexts, MAS might support tutoring dialogues, writing critiques, or collective planning. Designing such systems requires clear role definition and coordination protocols—like assigning agents to play researcher, writer, and editor in sequence.


---


### Reflex Agent

A reflex agent operates on a **simple stimulus-response rule**: if it sees input X, it performs action Y. It doesn’t plan, remember, or reflect—it just reacts. While limited, reflex agents are fast, predictable, and ideal for routine tasks. In a classroom setting, a reflex agent might be a Slackbot that posts “Got it!” whenever a file is uploaded, or formats every message with a certain keyword. While they lack flexibility, reflex agents are often building blocks in larger workflows where speed and simplicity are more important than deliberation.


---


### Deliberative Agent

A deliberative agent, by contrast, **reasons about its environment and possible actions** before choosing what to do. It forms internal models of goals, context, and outcomes, allowing it to pause and ask, “What should I do next—and why?” This is the dominant approach in LLM-based agents: they use prompts, memory, and tool access to choose actions deliberately. In an education app, a deliberative agent might decide whether to summarize a text, pull additional resources, or ask the user a clarifying question—all depending on its understanding of the user’s request and its current plan.


---


### Orchestration

Orchestration is the **coordination layer** that connects agents, tools, prompts, and data into a cohesive experience. It determines the order of operations, manages handoffs, handles errors, and ensures the system remains intelligible to the human user. In agentic workflows, orchestration might involve: “When the Slackbot receives a transcript, send it to Whisper → summarize → post summary → generate follow-up quiz.” Orchestration frameworks (like LangChain or CrewAI) help structure this logic, often acting as the invisible conductor behind agent-based teaching tools.


---


### Human-in-the-Loop (HITL)

A human-in-the-loop system integrates human judgment at key decision points—**ensuring that agents augment, rather than replace, human agency**. In classrooms, HITL might mean having a professor review a summary before it’s shared with students, or requiring approval before an agent updates shared documents. HITL makes agentic systems more trustworthy and pedagogically aligned—balancing the speed of AI with the nuance of human oversight. It’s especially important in high-stakes workflows like grading, feedback, or content generation.


---


### Reflection / Self-Critique

Reflection refers to an agent’s capacity to **evaluate its own outputs** and revise its behavior. For example, an agent might review a summary it just produced and ask, “Did I include the key ideas? Is anything missing?” This is typically implemented via prompt loops or subroutines, where the model critiques and possibly rewrites its previous output. Reflection improves quality, encourages revision, and simulates metacognitive behaviors that are central to human learning. For educators designing agentic tools, building in reflection means outputs are less brittle, more transparent, and potentially more aligned with academic expectations.


---


### Prompt Chaining

Prompt chaining is the practice of **linking multiple prompts together**, where each prompt performs a sub-task and passes its output to the next. This is one of the simplest ways to build agent-like behavior using large language models, without full autonomy. For instance, a three-step chain might: (1) summarize a transcript, (2) generate quiz questions from that summary, and (3) format those questions for LMS import. Prompt chains can be linear, branching, or iterative—and they’re widely used to prototype agentic systems in education, because they offer control, clarity, and modularity.


---


### State Machine

A state machine is a formal model where a system **moves between predefined states** (like “idle,” “collecting data,” “analyzing,” or “error”) based on inputs or conditions. While less flexible than LLM-based planning, state machines are robust, debuggable, and well-suited to **repeatable classroom automations**—such as polling workflows, assignment pipelines, or Slackbot interactions. In agentic design, state machines are often used to structure or constrain agent behavior, ensuring the system behaves predictably within a defined range of actions.


---


### OpenAI Agents SDK

The OpenAI Agents SDK is a framework that allows developers to build **LLM-powered agents** that can reason, plan, and take actions using tools, memory, and multi-turn logic. The SDK handles orchestration: it keeps track of the agent’s goal, determines what to do next, decides whether to use a tool or ask a clarifying question, and loops until the task is complete. For example, an agent might be given the goal “organize this folder of lecture transcripts,” and autonomously choose to summarize each file, rename them, and post links to Slack. The SDK is designed for scalable, production-level agents—ideal for research assistants, writing bots, or data organizers that work across sessions and contexts.


---


### LangChain

LangChain is a popular open-source framework that enables developers to build **modular agentic workflows** with large language models. It offers utilities for chaining prompts, managing memory, accessing tools, and integrating with external services (APIs, databases, file systems). In an educational context, LangChain might power an agent that reads a lecture transcript, tags key concepts, and posts a quiz to Canvas—all by moving data through a sequence of steps. LangChain is particularly helpful for structuring LLM workflows that combine logic, decision-making, and tool use—without requiring every step to be manually hardcoded.


---


### LangGraph

LangGraph is an extension of LangChain that adds **graph-based control flow**, enabling agents to move between nodes of logic with conditional branching, retries, and looping. Unlike linear chains, LangGraph workflows allow for dynamic paths: the agent can reflect, backtrack, or repeat steps if a condition isn’t met (e.g., “If quiz quality is low, regenerate.”). This makes LangGraph ideal for **more sophisticated agentic behavior**, such as iterative summarization, multi-agent collaboration, or real-time classroom feedback tools that require flexible decision-making.


---


### CrewAI

CrewAI is a Python framework that lets developers build **multi-agent systems** where each agent plays a defined role in a collaborative workflow. Think of it like assigning roles in a group project: one agent researches, another critiques, another writes. These agents communicate with each other using structured prompts, dividing labor and checking each other’s work. In a teaching setting, CrewAI might power an AI peer review system where one agent reads a student’s essay, another offers feedback, and a third generates a rubric-aligned evaluation. CrewAI emphasizes transparency and modularity—making it easy to see how agent decisions unfold across a team.


---


### Agent Simulation

Agent simulation refers to the practice of having **multiple AI agents simulate a dialogue, decision-making process, or interaction**, usually within a closed environment. It’s commonly used to study emergent behavior, test ideas, or generate creative material. For example, a classroom tool might simulate a philosophical debate between Aristotle and Kant, each played by an agent with different priors. Or a group of agents might act as a dissertation committee offering conflicting advice. These simulations don’t require real autonomy—they rely on scripted goals and prompts—but they are powerful for **pedagogical roleplay, prototyping, or design fiction**.


---


### Guardrails

Guardrails are constraints or safety checks that limit what an agent can do, when, and how. They protect against hallucination, misuse, or overreach—especially in educational or institutional settings. Guardrails might block access to certain tools (e.g., “this agent can’t post to Slack without approval”), require human signoff at key points, or filter outputs through content moderation systems. Some guardrails are technical (validators, assertions), while others are social or institutional (rubrics, review stages). The goal is to make agents **helpful, trustworthy, and aligned**—especially when deployed in environments like classrooms where reliability and ethics are critical.


---


### Reflection vs. Reflex

The distinction between reflection and reflex helps clarify two ends of the agent behavior spectrum. A **reflex agent** operates on simple, automatic rules—"if input A, then action B"—without analyzing context or history. These agents are fast and predictable but incapable of adaptation. A **reflective agent**, by contrast, can pause, review its actions, assess outcomes, and adjust its strategy. Reflection adds a metacognitive layer—an agent might evaluate its own summary, detect weak reasoning, and try again. In educational settings, reflex agents might be used for quick formatting or tagging, while reflective agents are better suited to tasks that benefit from judgment and revision, such as generating feedback or curating student questions.


---


### LLM-as-Agent vs. Agent-as-Framework

There’s a meaningful difference between using an **LLM as an agent** and building an **agentic framework around an LLM**. When you use an LLM as an agent, you prompt it directly with a task and rely on its internal reasoning to determine the outcome ("Write a study guide from this transcript"). This approach is lightweight but harder to debug or constrain. In contrast, an agent-as-framework approach wraps the LLM in a structured system: it defines tools, memory, steps, and controls what the LLM can and cannot do. In classroom tools, the second approach is often preferable: it allows **greater transparency, reliability, and human oversight**, especially when the agent is interacting with sensitive data or generating student-facing content.


---


### Backstage Agent

A backstage agent is an **invisible assistant** that supports the instructor without directly interacting with students. It might run in the background during a lecture, monitoring a Slack channel for common questions, summarizing discussion threads, or tagging points of confusion in a transcript. These agents are designed not to disrupt the flow of teaching—they serve the educator, not the class as a whole. In hybrid classrooms or large lectures, backstage agents help instructors maintain awareness of backchannel dynamics, surfacing trends or anomalies in real time.


---


### Assignment Assistant

An assignment assistant is an agentic tool that helps **students understand and engage with assignments more effectively**. It might annotate a syllabus or assignment prompt, explain grading criteria, suggest strategies for tackling a paper, or even generate a scaffold (like an outline or timeline). These agents do not complete the work for students, but they reduce ambiguity and increase access—particularly for first-generation students or those unfamiliar with disciplinary conventions. When designed thoughtfully, assignment assistants **model academic thinking**, helping students learn how to approach complex tasks with structure and confidence.


---


### Study Guide Generator

A study guide generator is an AI agent that reads course materials—lecture transcripts, slides, readings, or backchannel discussion—and produces structured review materials. This might include summaries of key concepts, flashcards, potential exam questions, or timelines. Unlike static handouts, these agents can tailor output to the week’s material or even to individual students’ notes or questions. Instructors can use these tools to scaffold test prep or to reinforce learning from class sessions. When integrated with memory or analytics, a study guide generator might also emphasize **content that students struggled with most**, making review more targeted and effective.
