CSE 410 / 510 Introduction to Agentic Engineering
Why consider this course?
- Work on interesting, real-world projects
- Explore a timely, emerging topic in computing
- Get a hands-on, project-driven experience with in-class labs and activities
- Open to both undergrads and grads
Important things to know
- Force Registration Required
- Enrollment is managed through force registration: arts-sciences.buffalo.edu/advising/academics/force-registration.html
- Active participation, presentations, and hands-on activities are required throughout the semester—not optional extras. Plan to engage in class each week.
- (Graduate Students) This course has been approved for a Fall 2026 MS capstone course- HOWEVER, you must be in the specialization version of the program for that to be an option for you. It will also count as an AI/ML depth (focus area) in research track and PhD program or an elective.
- (Undergraduate Students) This course can be used to satisfy any AI Elective.
If you’re looking for a course that’s flexible, project-focused, and a bit different from the usual offerings—and you’re ready to participate actively—this is a great option.
Course Description
Introduction to Agentic Engineering is a project-based undergraduate and graduate course on designing, building, testing, and responsibly deploying AI-powered agents: software systems that combine foundation models with tools, data sources, memory, planning, structured workflows, and human oversight. The course treats an agent not as a magic chatbot, but as an engineered system that senses a bounded environment, chooses actions through well-designed interfaces, uses tools, and is evaluated against explicit objectives and safety constraints.
Students will study the full agentic engineering stack: prompt and context design, tool/function calling, retrieval-augmented generation, embeddings and vector search, workflow graphs, state machines, planning, multi-agent coordination, evaluation, observability, security, and human-in-the-loop design. Mathematical topics will be introduced as engineering tools: vector spaces and similarity for embeddings; probability, uncertainty, and calibration; graph search and finite-state workflows; Markov decision processes and reinforcement-learning concepts; optimization and loss functions; and statistical evaluation through metrics, confidence intervals, bootstrapping, and error analysis.
The course culminates in a team project in which students build a useful agent for a bounded real-world task, document its architecture, create an evaluation suite, analyze risks, and present a working prototype.
Prerequisites & Target Audience
Intended audience: This course is offered under two course numbers. CSE 410 is for upper-division undergraduate students in Computer Science, Computer Engineering, Data Science, Cybersecurity, and related technical programs. CSE 510 is the graduate section for MS and PhD students seeking a graduate-level elective in agentic AI engineering.
Prerequisites: CSE 250 Data Structures or equivalent programming maturity, or approval by the instructor. Students should be comfortable writing Python programs, using Git/GitHub, reading technical documentation, and debugging code.
Recommended background (not required): CSE 331 Algorithms and Complexity; CSE 368 Introduction to Artificial Intelligence; CSE 442 Software Engineering; CSE 435 Information Retrieval; CSE 474 Introduction to Machine Learning, or equivalent experience. Mathematical maturity will help, but required mathematical ideas will be introduced in context.
Learning Outcomes
Upon successful completion of this course, students will be able to:
- Explain the difference between chatbots, workflows, tool-using LLM applications, and autonomous/semi-autonomous agents.
- Design a bounded agentic system by specifying its environment, goals, tools, memory, state, inputs, outputs, and failure modes.
- Implement agentic workflows using Python and contemporary frameworks or lightweight custom code.
- Use tool/function calling, structured outputs, retrieval, and embeddings to connect models to external information and actions.
- Model agent workflows using graphs, state machines, and planning/search concepts.
- Apply mathematical tools from linear algebra, probability, graph theory, optimization, reinforcement learning, and statistics to agent design and evaluation.
- Build evaluation harnesses for agent behavior, including task-level metrics, error taxonomies, regression tests, and human review.
- Analyze ethical, privacy, security, and social risks in agentic systems.
- Communicate technical designs through architecture diagrams, documentation, demos, and reflective analysis.
Mathematical Themes
The course introduces mathematical ideas in the context of engineering problems, not as prerequisites. Topics include:
Tentative Fall 2026 Schedule
UB's standard Fall 2026 session runs August 24 – December 7, 2026. The class meets Wednesdays, 5:00–7:40 PM. There is no class on Wed., Nov. 25 (Thanksgiving recess). Topics remain tentative and may shift as the semester progresses.
Weeks 1–8
| Wk | Dates | Topics | Math / Technical Focus | Major Work |
|---|---|---|---|---|
| 1 | Aug. 24–28 | What is agentic engineering? Agents, environments, tools, goals, constraints. | Agent = environment + actions + policy; system boundaries | Reading Note 1 |
| 2 | Aug. 31–Sep. 4 | Foundation models as components in software systems. Prompting, context, structured outputs. | Probability over tokens; uncertainty; structured outputs | Lab 1 assigned; Reading Note 2 |
| 3 | Sep. 8–11 | Tool/function calling and the ReAct pattern. Studio: linear algebra for machine learning. | Reasoning/action loops; action spaces; error propagation; vectors and cosine similarity | Reading Note 3; Math mini-assignment 1 assigned |
| 4 | Sep. 14–18 | Retrieval-augmented generation and context construction. | Vectors, cosine similarity, TF-IDF / BM25 intuition | Lab 1 due; Lab 2 assigned; Reading Note 4 |
| 5 | Sep. 21–25 | Embeddings, vector search, and reranking. | Nearest-neighbor search; precision/recall; retrieval evaluation | Math mini-assignment 1 due; Math mini-assignment 2 assigned |
| 6 | Sep. 28–Oct. 2 | Agent workflows: graphs, state machines, LangGraph/custom orchestration. | Directed graphs, finite-state machines, DAGs | Lab 2 due; Lab 3 assigned |
| 7 | Oct. 5–9 | Planning and decomposition. When should an agent plan? | Search, heuristics, task decomposition, cost functions | Project proposal due |
| 8 | Oct. 14–16 | Human-agent interaction, interface design, and human-in-the-loop. Agent memory architectures. | Decision thresholds; expected cost of errors; short-term, episodic, and long-term memory | Math mini-assignment 2 due; Midterm architecture review assigned |
Weeks 9–Final
| Wk | Dates | Topics | Math / Technical Focus | Major Work |
|---|---|---|---|---|
| 9 | Oct. 19–23 | Evaluation of agents. From single prompts to task-level evals. | Metrics, benchmarks, confidence intervals, bootstrapping | Lab 3 due; Lab 4 assigned |
| 10 | Oct. 26–30 | Security, privacy, prompt injection, tool misuse, and sandboxing. | Threat models; invariants; permission boundaries | Midterm architecture review due |
| 11 | Nov. 2–6 | Multi-agent systems and coordination. | Graph coordination, communication protocols, game-theoretic intuition | Lab 4 due; Lab 5 assigned |
| 12 | Nov. 9–13 | Coding agents, software engineering agents, testing, CI, and observability. | Regression tests, traces, reliability statistics | Project checkpoint |
| 13 | Nov. 16–20 | Applied agents: data science, scientific discovery, and education. Responsible deployment. | Experimental design; causal caution; calibration; risk analysis and accountability | Lab 5 due |
| 14 | Nov. 23–28 | No class — Thanksgiving recess (Nov. 25–28). Independent project work: finish the draft report and rehearse the demo. | — | Draft project report due before the Week 15 class |
| 15 | Nov. 30–Dec. 7 | Final demos, critique, and synthesis (Wed., Dec. 2). | Evidence-based evaluation of agent usefulness | Final demos in class |
| Final | Dec. 9–16 | Final project submission at assigned exam time. | Final evaluation report | Final report & repository due |
Major Assignments
Build a small Python agent that can choose among a calculator, a file reader, and a simple search or lookup function. Submit code, a short design note, and examples of successful and failed runs.
Create a small RAG pipeline using a course-selected document collection. Compare keyword retrieval, dense retrieval, and/or hybrid retrieval. Include cosine similarity calculations and an error analysis.
Implement an agentic workflow as a graph or state machine. The system should include explicit states, transitions, failure handling, and logging.
Design an evaluation suite for a bounded agent task. Include test cases, success criteria, metrics, a failure taxonomy, and a reproducible evaluation script.
Add a human approval step, structured outputs, guardrails, or permission boundaries to an agentic workflow. Analyze where autonomy is helpful and where it should be restricted.
Teams will design and build a working agent for a clearly bounded task. Deliverables include a problem statement, environment and tool inventory, architecture diagram, implementation repository, evaluation dataset or script, results and error analysis, security/privacy/ethical risk assessment, demo, and final written report.
Grading
| Component | Weight |
|---|---|
| Weekly reading/design notes, mathematical mini-assignments, quizzes, and participation (presentations and class engagement) | 25% |
| Labs and technical exercises | 35% |
| Team project | 30% |
| Final oral exam | 10% |
| Total | 100% |
Required and Recommended Materials
There is no single required textbook. Readings will be a mix of book chapters, technical documentation, research papers, and practitioner essays.
- Stuart Russell and Peter Norvig, Artificial Intelligence: A Modern Approach.
- Thomas R. Caldwell, The Agentic AI Bible.
- Chip Huyen, AI Engineering: Building Applications with Foundation Models. O'Reilly, 2025.
- Chip Huyen, "Agents." January 2025. huyenchip.com/2025/01/07/agents.html
- Anthropic, "Building Effective Agents." December 2024. anthropic.com/engineering/building-effective-agents
- OpenAI Agents SDK documentation. openai.github.io/openai-agents-python
- OpenAI function/tool calling documentation.
- LangGraph documentation. docs.langchain.com
- LlamaIndex documentation. docs.llamaindex.ai
- Yao et al., "ReAct: Synergizing Reasoning and Acting in Language Models," ICLR 2023.
- Schick et al., "Toolformer: Language Models Can Teach Themselves to Use Tools," 2023.
- Lewis et al., "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks," NeurIPS 2020.
- Park et al., "Generative Agents: Interactive Simulacra of Human Behavior," 2023.
- Jimenez et al., "SWE-bench: Can Language Models Resolve Real-World GitHub Issues?" 2023.
- Zhou et al., "WebArena: A Realistic Web Environment for Building Autonomous Agents," 2023.
- Sutton and Barto, Reinforcement Learning: An Introduction, 2nd ed.
Tools and Technical Environment
Students will use Python, Git/GitHub, Jupyter notebooks, command-line tools, and one or more agent frameworks. The course may use OpenAI-compatible APIs, open-source/local models, LangChain/LangGraph, LlamaIndex, vector databases or local vector stores, and lightweight web or API frameworks. Exact tools may be adjusted based on UB infrastructure, student access, and current best practices in Fall 2026.
Students should expect to document their work clearly and maintain reproducible repositories. Where paid APIs are used, alternatives or credits will be provided when possible. Students may also use local models through tools such as Ollama when technically appropriate.