Synthesis and Future Directions

Duration: 2 hours lecture + 1 hour discussion/presentations Prerequisites: Weeks 1-14 (complete course)

---

01Learning Objectives

By the end of this lecture, students will be able to:

1. Articulate the complete agentic AI stack and explain how each component contributes to agent capabilities
2. Synthesize concepts from across the course into a coherent understanding of agentic systems
3. Identify current limitations of agentic AI and formulate them as research problems
4. Evaluate emerging trends in agentic AI and assess their potential impact
5. Provide a realistic assessment of the path from current agents to more general AI
6. Identify career opportunities in the agentic AI ecosystem
7. Reflect on the ethical responsibilities of agentic AI practitioners

---

021. Synthesis: The Agentic AI Stack

1.1 Looking Back to Look Forward

Over the past fourteen weeks, we have built up a comprehensive understanding of agentic AI systems, layer by layer, like constructing a building from foundation to roof. Each week added new concepts, but it is only now, at the end, that we can step back and see the complete architecture.

This final lecture has a different character from the previous ones. Instead of introducing new technical material, we are going to do three things: (1) synthesize everything we have learned into a unified picture, (2) identify what we cannot yet do and why, and (3) look forward to where the field is heading.

Let us begin by putting the entire stack in one place.

1.2 The Complete Picture

This stack is not just a summary; it is an architectural blueprint. Every real-world agentic system, from a simple chatbot with tool access to a complex multi-agent research system, can be described in terms of which layers it uses and what choices it makes at each layer.

1.3 How the Layers Interact

The stack is not strictly hierarchical. The layers interact bidirectionally, and this bidirectional interaction is what makes agentic systems both powerful and complex.

Bottom-up flow (capability). Foundation models provide language understanding and generation. Tools extend capabilities beyond text into the real world. Memory enables persistence and learning. Planning orchestrates complex behavior across multiple steps. Multi-agent coordination enables collective intelligence. Human interaction grounds the system in real-world needs. Governance ensures safe operation.

Each layer builds on the one below it. Without foundation models (Layer 1), you cannot have tool use (Layer 2). Without memory (Layer 3), planning (Layer 4) cannot learn from past attempts. Without planning, multi-agent coordination (Layer 5) has nothing to coordinate.

Top-down flow (constraint). Governance defines what the agent is allowed to do. Human oversight shapes agent behavior through feedback and approval. Coordination protocols constrain how agents interact. Planning determines which tools to use and when. Memory provides context for tool selection. Tools ground model outputs in reality.

Each layer constrains the ones below it. Governance (Layer 7) limits what tools can be used (Layer 2). Human oversight (Layer 6) shapes what plans are acceptable (Layer 4). This top-down flow is what makes agents safe, not just capable.

Cross-layer interactions. Safety guardrails (Layer 7) operate at every other layer: filtering inputs to the model (Layer 1), constraining tool access (Layer 2), limiting what the agent can remember (Layer 3), validating plans (Layer 4), governing inter-agent communication (Layer 5), and mediating human interaction (Layer 6). Memory (Layer 3) informs planning (Layer 4) and is enriched by tool outputs (Layer 2) and human feedback (Layer 6).

Key Insight: The most common architectural mistake in agentic AI is building layers 1-4 (the "cool" stuff) without adequate investment in layers 5-7 (the "boring" stuff). A capable agent without governance, human interaction, and coordination is a liability, not an asset.

1.4 The Design Space

Every agentic system makes choices at each layer. These choices define the system's position in a multi-dimensional design space:

There is no single "best" configuration. A customer service chatbot needs different design choices than an autonomous research agent, which needs different choices than a coding assistant. The right configuration depends on the application domain, risk tolerance, performance requirements, and cost constraints.

1.5 Concept Map: How All 14 Weeks Connect

Beyond the linear stack, the concepts from this course form a rich web of connections. Understanding these connections is key to mastering agentic AI as a system discipline, not just a collection of techniques.

The connections are not just linear. Here are the most important cross-connections:

Week 3 (Prompting) connects to every week. Prompting is the fundamental skill that appears at every layer: prompting for tool use, prompting for memory retrieval, prompting for planning, prompting for safety, prompting for coding agents. A student who masters prompting from Week 3 has a tool that applies everywhere.

Week 10 (Evaluation) connects back to every capability. You cannot build reliable agents without evaluating them, and evaluation is specific to each capability: evaluating tool use accuracy, memory retrieval quality, plan quality, safety compliance, and overall task performance.

Week 11 (Safety) and Week 14 (Governance) form a reinforcing pair. Safety is the technical implementation; governance is the organizational and legal framework. Neither is sufficient without the other. A technically safe agent without governance policies may be deployed inappropriately. A governance framework without technical safety measures is empty compliance.

Week 12 (Human Interaction) mediates between capability and safety. The human-in-the-loop patterns from Week 12 are the bridge between the agent's capabilities (Weeks 1-10) and its safety constraints (Weeks 11, 14). The quality of human oversight determines whether a capable agent is also a safe one.

Key Insight: The most effective agentic AI practitioners do not think about individual components in isolation. They think about systems: how prompting affects safety, how memory affects planning, how evaluation informs governance, and how human interaction shapes trust. This systems thinking is the meta-skill of the course.

Try It Yourself: Map Your Project to the Stack

Take the agent you built for your final project (or any agent you have worked with). For each layer of the stack, identify:

1. What choice did you make at this layer?
2. Why did you make that choice?
3. What would you change if you had more time?
4. What are the risks of your current choice?

This exercise makes the abstract stack concrete by connecting it to your own experience.

---

032. What We Covered and How It Connects

2.1 Course Arc

The course followed a deliberate progression, designed so that each week built naturally on the previous ones:

Weeks 1-4: Foundations. We established what agents are, how LLMs work as their cognitive core, and how prompting and fine-tuning shape their behavior. This gave us the vocabulary and conceptual grounding for everything that followed.

The key concept from this section: agents are systems that perceive, reason, and act in a loop. Everything else in the course is about making that loop more capable, more reliable, and more safe.

Weeks 5-7: Capabilities. We added the components that transform a language model into an agent: tool use (acting in the world), retrieval (accessing external knowledge), and memory (learning and persisting state). These are the capabilities that distinguish agents from chatbots.

The key concept from this section: grounding. A language model without tools is generating text. A language model with tools is taking action. The shift from generating to acting is the fundamental shift from a chatbot to an agent.

Weeks 8-10: Intelligence. We explored how agents think and work together: planning and reasoning for complex tasks, evaluation and testing for reliability, and multi-agent systems for collective problem-solving. These are the cognitive architectures that enable sophisticated behavior.

The key concept from this section: complexity management. Real-world tasks are too complex for a single reasoning step. Planning, decomposition, reflection, and coordination are how agents manage complexity.

Weeks 11-14: Responsibility. We addressed the challenges of deploying agents responsibly: safety and alignment (preventing harm), human interaction (keeping humans in control), practical applications (software engineering), and governance (meeting legal and ethical requirements). These are the guardrails that make agents trustworthy.

The key concept from this section: agents are sociotechnical systems. They exist in a context of human users, legal frameworks, organizational policies, and societal norms. Technical excellence without social responsibility is insufficient.

Week 15: Synthesis. We bring it all together and look forward.

2.2 Week-by-Week Connections

Let us trace how specific concepts from earlier weeks enable later concepts:

Tool use (Week 4-5) enables everything. Without tools, an agent is just a chatbot. Tool use is the foundational capability that makes memory possible (tools to read/write memory stores), planning actionable (tools to execute plan steps), multi-agent communication possible (tools to send messages), safety enforceable (tools that implement guardrails), and software engineering viable (tools to read/write files, run commands).

Memory (Week 6-7) enables personalization and improvement. Without memory, every interaction starts from scratch. Memory is what allows progressive autonomy (Week 12), because the agent can remember its track record. Memory is what allows feedback-based improvement (Week 12), because corrections are stored and applied in future interactions. Memory is what enables long-horizon tasks (Section 3.2 above), because the agent can maintain context beyond the immediate context window.

Planning (Week 9) enables complex tasks. Without planning, an agent can only handle tasks that fit in a single reasoning step. Planning is what makes multi-file code changes possible (Week 13), multi-step research possible (Week 8), and multi-agent coordination effective (Week 8). Planning is also what makes safety harder (Week 11), because a multi-step plan has more opportunities to go wrong than a single action.

Evaluation (Week 10) enables trust. Without evaluation, you cannot know whether your agent works. Evaluation is the empirical foundation for progressive autonomy (Week 12), because you need data to justify increasing autonomy. Evaluation is the basis for governance compliance (Week 14), because you need evidence that your agent meets regulatory requirements. Evaluation is what separates engineering from hope.

2.3 Key Themes Across the Course

Several themes recurred throughout the entire course, appearing in different forms at different layers:

The capability-safety tradeoff. More capable agents can do more good but also more harm. Every capability increase demands a corresponding safety improvement. This theme appeared in Week 5 (tool access creates new risks), Week 8 (more sophisticated planning can pursue misspecified goals more effectively), Week 10 (multi-agent systems can amplify individual agent failures), and Week 11 (the entire lecture on safety).

The importance of grounding. Pure language models generate plausible-sounding text. Tools, retrieval, and memory ground agent behavior in reality. Grounding is what makes agents useful rather than just fluent. Without grounding, an agent is like a confident person who has read many books but never left their house: articulate but potentially disconnected from reality.

The human role. Despite the "autonomous" label, humans remain essential in agentic AI: as designers, overseers, feedback providers, and ultimate decision-makers. The question is not whether humans are involved but how. This theme appeared explicitly in Week 12 but was present in every week.

The engineering challenge. Building reliable agents requires solving hard engineering problems: managing state, handling failures, ensuring consistency, maintaining security, logging everything, recovering from errors. Agentic AI is as much software engineering as it is AI research. The most brilliant agent architecture is useless if it crashes in production.

---

043. Current Limitations and Open Research Problems

3.1 Reliability and Consistency

The problem. Current agents are unreliable. The same prompt may produce different plans and different outcomes across runs. An agent may succeed on a task 70% of the time but fail unpredictably on the remaining 30%. For production systems, this unreliability is a major barrier. Traditional software is expected to work correctly 99.999% of the time. Agents are nowhere near that standard.

To put this in perspective with an analogy: imagine a car that starts 70% of the time. You would never buy it. Now imagine a software developer who writes correct code 70% of the time. You would never hire them. Yet we are building agents with roughly that reliability and hoping they will be useful. They are useful, but only because human oversight catches many of the failures. The path to wider deployment requires dramatically improving this number.

The unreliability is not just random noise. It is structured: agents tend to fail on specific types of inputs, specific types of tasks, or specific combinations of conditions. But these failure conditions are hard to characterize in advance, making it difficult to know when to trust the agent and when not to. A coding agent might be 95% reliable on Python tasks but only 60% reliable on Rust tasks, and you may not know this until you have run hundreds of tasks.

Open research questions:

• How can we make agent behavior more deterministic without sacrificing the flexibility that makes agents useful? (Hint: deterministic does not mean "same output every time"; it means "consistently correct output".)
• What formal verification techniques can be applied to agent plans? Can we prove that a plan is safe before executing it?
• How do we define and measure "reliability" for non-deterministic systems? Traditional software testing assumes deterministic behavior. What is the equivalent for agents?

A concrete example. Consider a coding agent asked to "add input validation to the user registration endpoint." Across 10 runs with the same prompt and the same codebase, the agent might:

• Runs 1-3: Add validation correctly using the project's existing validation library
• Run 4: Add validation but use a different validation library that is not in the project's dependencies
• Run 5: Add validation correctly but in a slightly different location in the code
• Runs 6-8: Add validation correctly, matching runs 1-3
• Run 9: Misunderstand "user registration" and add validation to the login endpoint instead
• Run 10: Add validation correctly but introduce a subtle bug in the error message formatting

Seven of ten runs are correct, but the failure modes are diverse and unpredictable. The developer must review each output as if it might be wrong, because they cannot predict which runs will fail.

Why this matters for practitioners: Until agents are reliable enough for production use, they will be limited to assisting humans rather than replacing them. Improving reliability is the single most impactful research direction for expanding the practical applications of agents.

3.2 Long-Horizon Tasks

The problem. Agents perform well on tasks that take minutes but degrade significantly on tasks that take hours or days. Errors accumulate, context is lost (as the task exceeds the model's context window), and the agent drifts from its original goal.

This is partly a context window limitation (current models can hold 100K-1M tokens, which sounds like a lot but fills up quickly over hours of work), partly a planning limitation (long-horizon plans require predicting the consequences of actions many steps ahead), and partly an error propagation problem (small errors at step 5 can cause large errors at step 50).

A concrete example. Ask a coding agent to implement a complete feature that requires changes to 15 files across the frontend, backend, and database layers. The agent starts well, correctly modifying the first 5-6 files. But by file 10, it has lost track of a naming convention it established in file 3. By file 13, it introduces an inconsistency with the database schema it created in file 7. By file 15, the tests fail because of accumulated inconsistencies. A human developer maintaining a mental model of the entire change would catch these inconsistencies; the agent, with its limited working memory, loses track.

Open research questions:

• How should agents manage context over extended periods? Current approaches include context summarization, hierarchical memory, and selective retrieval, but none is fully satisfactory. The fundamental tension is between compression (needed to fit in the context window) and fidelity (needed to avoid losing important details).
• What planning architectures enable effective long-horizon execution? Hierarchical planning (plans within plans) is promising but raises questions about plan coherence. How does a high-level plan stay consistent when the low-level steps modify the environment in unexpected ways?
• How do we detect and correct drift in agent behavior? If the agent slowly deviates from its goal over hundreds of steps, how do we notice? One approach is periodic "checkpoint and review" where the agent pauses, summarizes what it has done, and checks alignment with the original goal. But this requires the agent to be a reliable self-assessor, which is itself an open problem.

3.3 Reasoning Depth

The problem. LLMs perform well on tasks requiring pattern matching and surface-level reasoning but struggle with tasks requiring deep, multi-step logical reasoning, mathematical proof, or causal inference. Chain-of-thought helps but does not solve the fundamental limitation.

Consider the difference between "what does this function do?" (which agents handle well, by pattern-matching against many similar functions they have seen in training) and "will this function always terminate for all possible inputs?" (which requires genuine logical reasoning about program behavior). The first is pattern recognition; the second is mathematical proof. Current agents are much better at the first than the second.

Open research questions:

• Can LLM-based agents achieve genuine logical reasoning, or do they fundamentally rely on sophisticated pattern matching? This is a deep philosophical question with practical implications.
• How can we combine neural reasoning (LLMs) with symbolic reasoning (formal logic, constraint solvers, theorem provers) effectively? Neuro-symbolic AI is a promising but challenging direction.
• What training approaches improve reasoning depth? Recent work on reasoning models (OpenAI's o1 series, DeepSeek-R1) shows that training specifically for reasoning can yield dramatic improvements. How far can this approach go?

3.4 Robust Tool Use

The problem. Agents make errors in tool selection, parameter construction, and output interpretation. They may call the wrong tool, pass incorrect arguments, or misinterpret results, especially with tools they have not encountered during training.

A concrete example. An agent with access to both a search_web tool and a search_codebase tool is asked to "find how authentication is implemented." It should use search_codebase but might use search_web if the model associates "find" more strongly with web search. Even when it selects the right tool, it might construct the query poorly: searching for "authentication" when "auth" or "login" would return better results in the codebase. And even when the search returns correct results, the agent might misinterpret a comment in the code as the actual implementation.

Open research questions:

• How can agents learn to use new tools from documentation alone, without having seen examples in training? This is the "zero-shot tool use" problem. Current agents perform well with tools they have been fine-tuned on but struggle with novel tools.
• What interface designs minimize tool-use errors? The SWE-agent work (Week 13) showed that tool design matters enormously. What principles should guide tool design for agents? Preliminary evidence suggests that tools should have clear, unambiguous names, provide structured output, and include examples in their descriptions.
• How can we formally verify that an agent's tool calls are correct? Can we automatically check that the parameters are valid before executing the call? This is related to the broader problem of plan verification.

3.5 Safety and Alignment

The problem. Current safety measures (guardrails, RLHF, Constitutional AI) reduce harmful behavior but do not eliminate it. Prompt injection remains an unsolved fundamental problem. Alignment is achieved through training and rules, not through the agent genuinely understanding and sharing human values.

Open research questions:

• Is robust defense against prompt injection achievable in principle? Or is it like the halting problem: fundamentally unsolvable?
• Can we develop alignment techniques that generalize to novel situations the agent was never trained on?
• How do we align agents in multi-stakeholder scenarios where different humans have conflicting values? An agent serving a company and its customers may face situations where the company's interests and the customer's interests diverge.

3.6 Evaluation and Benchmarking

The problem. Evaluating agents is fundamentally harder than evaluating models. Agent behavior is contextual, sequential, and environment-dependent. Current benchmarks (SWE-bench, WebArena, GAIA) capture narrow slices of agent capability.

A concrete example. How do you evaluate a customer service agent? Task completion rate (did the customer's issue get resolved?) is necessary but insufficient. You also need to measure: response quality (was the information accurate?), efficiency (how many steps did it take?), safety (did the agent share sensitive data?), user satisfaction (was the customer happy?), fairness (do customers from different groups receive different service?), and cost (how much compute did it use?). No single metric captures all of these, and they can be in tension (faster resolution might mean less careful answers).

Open research questions:

• How do we evaluate agents on open-ended, real-world tasks where the correct answer is not predetermined? SWE-bench works because bugs have clear fixes. Many real-world tasks (writing a report, planning a project, advising a customer) do not have a single "correct" answer.
• What metrics capture the quality of agent behavior beyond task completion? (e.g., efficiency, safety, user experience, fairness). The field needs a standardized "scorecard" for agent quality.
• How do we benchmark safety and alignment in a meaningful way? Current safety evaluations often use artificial scenarios that do not reflect real-world deployment conditions. An agent that passes artificial safety tests may still fail in novel real-world situations.
• How do we evaluate multi-agent systems? The behavior of the system is not just the sum of individual agent behaviors; it emerges from their interactions.

3.7 Summary: State of the Field

Key Insight: The limitations listed above are not just academic curiosities. They are the barriers that currently prevent wider deployment of agentic AI. If you are looking for a research direction or a career focus, these are the problems that matter most. Notice that reliability is the primary barrier: even modest improvements in reliability would unlock significantly wider deployment.

---

054. Emerging Trends

Try It Yourself: Formulate a Research Problem

Pick one of the limitations above that interests you most. Write a one-paragraph "research problem statement" that:

1. Describes the limitation concretely (with an example)
2. Explains why it matters practically
3. Identifies one possible approach to addressing it
4. Identifies the main challenge with that approach

This exercise practices a critical skill for anyone in the field: the ability to articulate a problem clearly and identify a path toward a solution.

---

064. Emerging Trends

The limitations in Section 3 define where the field is today. The trends in this section suggest where it is going. Some of these trends address the limitations directly; others open entirely new application domains.

4.1 Autonomous Scientific Discovery

AI agents are beginning to participate in the scientific research cycle itself. This is arguably the most consequential emerging trend because accelerating scientific discovery has compounding effects on every other field.

Literature review agents. Systems that read, summarize, and synthesize scientific papers, identifying gaps and generating hypotheses. Tools like Semantic Scholar, Elicit, and Consensus demonstrate early capabilities. These agents can process thousands of papers and identify patterns that no human researcher could spot by reading individually.

Experiment design agents. Agents that propose experimental designs, including parameter ranges, control conditions, and analysis plans. Boiko et al. (2023) demonstrated an "Autonomous Scientific Research Agent" that could design and execute chemistry experiments, including selecting reagents, planning synthesis steps, and interpreting results.

Lab automation agents. Agents that control robotic laboratory equipment to execute experiments. The integration of AI planning with physical automation is still early but advancing rapidly in fields like drug discovery and materials science.

The vision. A full research cycle where agents generate hypotheses, design experiments, execute them (in simulation or with robotic labs), analyze results, and write papers. This remains aspirational for most fields, but the components are being assembled. The question is not whether this will happen but when and how much human oversight will remain.

Current practical applications. Even before full autonomous research is realized, agents are already accelerating science in concrete ways:

• Literature search agents that find and summarize relevant papers in minutes instead of hours
• Data analysis agents that explore datasets, generate visualizations, and identify patterns
• Statistical analysis agents that select and run appropriate tests, check assumptions, and report results
• Writing assistants that help structure papers, check consistency, and format references
• Code generation for research (simulation scripts, data processing pipelines, statistical analyses)

These are not replacing scientists; they are amplifying them. A researcher with an effective AI assistant can review more literature, analyze more data, and write more clearly than one without. The productivity gains are real and immediate, even while the grander vision of autonomous discovery remains aspirational.

Key Insight: Autonomous scientific discovery is perhaps the highest-impact application of agentic AI. If agents can accelerate scientific research even modestly, the compounding effects on human knowledge and technology would be enormous. But the safety requirements are also high: an agent that generates false scientific findings or conducts unethical experiments could cause serious harm.

4.2 Agentic Robotics

The convergence of LLMs and robotics is creating a new generation of intelligent robots:

Language-conditioned control. Robots that understand natural language instructions and translate them into physical actions. Brohan et al. (2023) demonstrated RT-2, which uses a vision-language model to directly output robot actions from natural language commands and visual observations.

Planning for physical tasks. Using LLMs to decompose high-level instructions ("make me a sandwich") into physical action sequences ("open fridge, locate bread, grasp bread, ..."). Ahn et al. (2022) introduced SayCan, which grounds LLM plans in a robot's actual physical capabilities. The LLM proposes actions, and a learned affordance model filters them by what the robot can actually do. The LLM might suggest "fly to the kitchen" but the affordance model knows the robot cannot fly.

Generalizable manipulation. Moving beyond task-specific programming to robots that can handle novel objects and situations through general reasoning. This is the robotics equivalent of the shift from Stage 2 to Stage 4 in coding: from pre-programmed behavior to adaptive, reasoning-based behavior.

4.3 AI-Native Software

A paradigm shift is emerging in how software is built and used:

Generative UI. Instead of designing fixed interfaces, agents generate user interfaces dynamically based on the user's needs and context. Vercel's v0 and similar tools demonstrate early versions: you describe the interface you want, and the system generates it. The logical endpoint is software that has no fixed interface at all, adapting to each user and each task.

Natural language as interface. Applications where the primary user interface is natural language conversation, with the agent constructing the appropriate backend operations. This is already the paradigm for tools like Claude Code. Instead of clicking through menus, you describe what you want.

Self-modifying applications. Software that can modify its own code to add features, fix bugs, or adapt to new requirements. Combined with testing and deployment pipelines, this enables rapid, autonomous software evolution. This idea sounds futuristic, but it is essentially what happens when you use a coding agent to modify a deployed application.

Infrastructure agents. AI agents that manage cloud infrastructure: scaling resources, optimizing configurations, responding to incidents, and managing deployments. These extend existing DevOps automation with greater autonomy and intelligence.

Ephemeral applications. A paradigm where software is generated on-the-fly for specific tasks and discarded after use. Instead of building a permanent application for every need, an agent generates a single-use application (a dashboard, a data analysis tool, a form) tailored to the immediate task. This challenges fundamental assumptions about software development: software stops being a permanent artifact and becomes a temporary tool generated on demand.

Key Insight: The emerging trends all share a common pattern: agents are moving from tools that assist with existing workflows to tools that create entirely new workflows. The shift from "AI that helps you write code" to "AI that writes code for you" is just the beginning. The next shift is from "AI that writes code" to "AI that creates and runs software that never existed as a permanent artifact."

4.4 Personalized Agents

Long-term personal assistants. Agents that accumulate knowledge about a user over months and years, providing increasingly personalized assistance. The memory systems from Week 7 are foundational to this. The challenge is maintaining a useful memory while respecting privacy and avoiding the filter bubble problem (where the agent reinforces the user's existing preferences and beliefs rather than challenging them).

Digital twins. Agent representations of individuals that can act on their behalf, making decisions consistent with their preferences and values. This raises profound questions about identity, consent, and autonomy. If a digital twin of you makes a decision while you are asleep, are you bound by it?

Agents as collaborators. Moving beyond task-oriented agents (do this specific thing) to agents that maintain ongoing collaborative relationships, understanding context, preferences, working style, and long-term goals. The "colleague model" from Week 12, extended over months or years.

Privacy-preserving personalization. A key challenge for personalized agents is collecting enough information about the user to be helpful without creating a surveillance system. Emerging approaches include:

• On-device memory stores that never leave the user's device
• Federated learning where the model improves from user behavior without centralizing the data
• User-controlled memory where the user can see, edit, and delete everything the agent knows about them
• Differential privacy techniques that add noise to prevent individual identification while preserving aggregate patterns

The technical and ethical challenges of personalized agents will likely be one of the defining issues of the next decade of AI development.

4.5 Multi-Modal Agents

A trend that is advancing rapidly is agents that operate across multiple modalities: text, images, audio, video, and physical interaction.

Vision-enabled agents. Agents that can see and interpret images and screenshots. Claude's computer use capability (screenshots plus mouse/keyboard actions) is an early example. Future agents will combine visual understanding with traditional tool use, enabling tasks like "look at this dashboard screenshot and identify the anomaly" or "review this design mockup and suggest improvements."

Audio-enabled agents. Agents that can participate in phone calls, meetings, and voice interactions. Combined with real-time speech-to-text and text-to-speech, agents can handle tasks that require verbal communication (customer service calls, meeting facilitation, tutoring sessions). The challenge is that audio interactions are real-time and less forgiving of latency than text interactions.

Video-enabled agents. Agents that can watch video content, understand visual narratives, and produce video content. Applications include video editing agents, surveillance analysis agents, and educational content creation agents. This is still early but advancing rapidly.

Physical-digital agents. Agents that coordinate actions across digital systems and physical devices. A manufacturing agent that monitors sensors, analyzes data, adjusts machine parameters, and orders replacement parts spans the digital-physical boundary. This integration is challenging because physical systems are less predictable than digital ones and failures can have physical consequences.

4.6 Agent Marketplaces and Ecosystems

Agent-to-agent commerce. Agents that hire other agents to perform subtasks, creating economic ecosystems of specialized agents. Imagine your personal agent needing legal advice: it contracts with a legal research agent, pays a fee, and receives the analysis.

Agent platforms. Platforms that host, deploy, and manage agents, analogous to app stores. OpenAI's GPT Store and Anthropic's Claude integrations are early examples.

Interoperability standards. Protocols for agents built on different platforms to communicate and collaborate. The Model Context Protocol (MCP) and similar initiatives aim to standardize agent-tool and agent-agent interfaces. Without interoperability, the agent ecosystem will fragment into incompatible silos.

The governance challenge of agent ecosystems. Agent marketplaces and ecosystems raise governance questions that do not exist for single agents. If your agent hires another agent to perform a subtask and that agent makes a mistake, who is liable? How do you ensure quality control in a marketplace of thousands of agents? How do you prevent malicious agents from infiltrating the ecosystem? These questions mirror the challenges that app stores face (malware, quality control, liability) but are amplified by agents' ability to take consequential actions.

Try It Yourself: Predict the Future

Make three specific, time-bound predictions about agentic AI. Write them down with enough specificity that you (or someone else) can evaluate them in the future.

Good predictions:

• "By December 2027, at least one coding agent will solve 80%+ of SWE-bench Verified problems."
• "By 2028, the EU AI Act will be amended to include agent-specific provisions."
• "By 2030, at least one Fortune 500 company will report that AI agents handle 50%+ of its customer service interactions without human review."

Bad predictions (too vague):

• "AI will get better."
• "Regulation will increase."
• "Agents will transform software engineering."

Write your predictions somewhere you can find them. Revisit in 2-5 years. Being wrong is fine; the value is in practicing specific, reasoned prediction.

---

075. The Path from Current Agents to AGI: A Realistic Assessment

Try It Yourself: Trend Analysis

Choose one of the emerging trends above and write a brief analysis:

1. What technical capabilities (from our course) does this trend rely on?
2. What current limitations (from Section 3) must be overcome for this trend to reach maturity?
3. What are the potential positive and negative societal impacts?
4. What governance frameworks (from Week 14) would be relevant?

This exercise practices the systems thinking that connects technical capabilities to real-world impact.

5.1 What Current Agents Can Do

As of 2026, the most capable agents can:

• Follow complex multi-step instructions with high accuracy
• Use dozens of tools to interact with software systems
• Write, test, and debug code at a junior-to-mid developer level
• Conduct research across large document collections
• Maintain short-term and limited long-term memory
• Collaborate with humans on intellectual tasks
• Operate within defined safety boundaries
• Solve approximately 50-60% of real-world software engineering tasks autonomously

These capabilities would have been considered science fiction just five years ago. The progress has been extraordinary.

To put this in perspective with a concrete timeline:

• 2020: GPT-3 could generate text but could not use tools, maintain memory, or execute plans. Agents were academic concepts.
• 2022: ChatGPT demonstrated conversational AI to the public. Code generation tools appeared but were limited to autocomplete. No agent frameworks existed.
• 2023: The first agent frameworks (LangChain, AutoGPT) appeared. Tool use became practical. ReAct and similar patterns were demonstrated. The field of agentic AI was born.
• 2024: Production-quality coding agents (Claude Code, Cursor, Devin) appeared. SWE-bench became the standard benchmark. Multi-agent systems moved from research to practice.
• 2025-2026: Agent frameworks matured (OpenAI Agents SDK, Claude Agent SDK). MCP standardized tool access. Governance frameworks (EU AI Act) began to take effect. Computer use enabled visual interaction.

This timeline shows approximately 3 years from "agents are a research concept" to "agents are production tools." The pace of change is extraordinary, and it shows no signs of slowing down.

5.2 What Current Agents Cannot Do

Despite their impressive capabilities, current agents have fundamental limitations:

Genuine understanding. Agents manipulate symbols and patterns but do not demonstrably understand meaning in the way humans do. They can discuss quantum physics fluently without understanding what a photon is. Whether this matters practically (the "Chinese Room" debate) is contested, but it manifests as unexpected failures when the agent encounters situations that require understanding rather than pattern matching.

Novel reasoning. Agents struggle with problems that require genuinely novel insight, as opposed to recombining patterns from training. They can solve problems that are variations of problems they have seen, but they struggle with problems that require a genuinely new approach. This is the difference between a chess engine (which searches known patterns) and a mathematician (who invents new proof techniques).

Physical world interaction. Outside of controlled robotic settings, agents cannot interact with the physical world. They can control a robot arm in a lab but cannot navigate a cluttered kitchen or repair a car. Physical intelligence remains far behind linguistic intelligence.

Self-improvement. Agents do not genuinely improve themselves through experience in the way humans learn. Fine-tuning and in-context learning provide limited adaptation, but an agent that has been running for a year is not fundamentally smarter than one that has been running for a day (unless it has been retrained during that time).

Robust common sense. Agents make errors that reveal gaps in common-sense understanding, especially about physics ("can a ball roll uphill?"), social norms ("is it appropriate to discuss salary at a dinner party?"), and causality ("if I drop a glass, what happens?"). These errors are intermittent, which makes them harder to catch than systematic errors.

Persistent goals. Agents do not have genuine goals or motivations. They pursue objectives because they are instructed to, not because they want to. This is actually a safety feature (we do not want agents that want things), but it limits their ability to autonomously pursue long-term objectives.

Genuine creativity. Agents can recombine patterns in novel ways (which can look creative) but do not have the flash of insight that leads to genuinely original ideas. They can write a sonnet in the style of Shakespeare (pattern recombination) but are unlikely to invent a new poetic form (genuine creativity). This matters most in research, art, and innovation, where the highest-value contributions come from genuinely new ideas.

Social and emotional intelligence. Agents can simulate empathy and social awareness in text, but they do not understand social dynamics, emotional states, or interpersonal relationships in any deep way. A customer service agent can say "I understand your frustration" without understanding frustration. This limits their effectiveness in roles that require genuine social intelligence (counseling, negotiation, mentoring).

5.3 Common Misconceptions About Agent Capabilities

Before discussing AGI, let us address some common misconceptions that distort the public conversation:

Misconception: "LLMs understand language." More accurately, LLMs are very good at predicting what text should come next given prior text. Whether this constitutes "understanding" depends on your definition. Practically, it means agents can process and generate language fluently but may fail on tasks that require genuine comprehension (like following complex spatial reasoning or understanding physical causation).

Misconception: "Agents are getting smarter exponentially." Progress is rapid but uneven. Performance on some benchmarks (code generation, question answering) has improved dramatically. Performance on others (long-horizon planning, novel reasoning) has improved more slowly. The trajectory is not a smooth exponential curve; it is a jagged line with some areas advancing faster than others.

Misconception: "If agents can pass tests, they understand the material." Agents can pass standardized tests by leveraging patterns in the test format, not by understanding the underlying concepts. An agent that passes a bar exam has not "learned law"; it has learned to generate text that matches the patterns of correct legal exam answers. This is useful but different from genuine expertise.

Misconception: "Current agents are a few tweaks away from AGI." This dramatically understates the gap between current capabilities and general intelligence. Solving SWE-bench at 60% is impressive but still means 40% failure on well-defined tasks in a single programming language. The gap between 60% on defined tasks and human-level general intelligence is enormous.

5.4 The AGI Question

Artificial General Intelligence (AGI) is defined differently by different communities. A useful working definition: AGI is an AI system that can perform any intellectual task that a human can, at a comparable level, without task-specific training.

Arguments that AGI is near (the "scaling hypothesis"):

• Scaling model size and training data has consistently improved capabilities
• Emergent abilities appear at larger scales (though the nature and reality of "emergence" is debated)
• Combining LLMs with tools, memory, and planning creates increasingly general systems
• The rate of improvement appears to be accelerating

Arguments that AGI is far or may require new paradigms:

• Current systems lack genuine understanding and causal reasoning
• Scaling may face diminishing returns on reasoning-heavy tasks
• Physical grounding remains a fundamental challenge
• Current safety and alignment approaches may not scale to much more capable systems
• The "easy gains" may be behind us; remaining challenges may require fundamentally new approaches

A balanced view. Current agentic AI systems are extraordinarily useful and will continue to improve. Whether they are on a direct path to AGI or represent a local optimum that will require new paradigms to transcend is genuinely uncertain. Honest researchers disagree, and predictions about AI timelines have a poor track record.

What we can say with confidence:

• Current agents are far more capable than anyone predicted five years ago
• The rate of improvement shows no signs of slowing down
• Fundamental limitations (reliable reasoning, genuine understanding) have not been solved and may require new approaches
• The practical utility of current agents is enormous even without AGI
• The safety and governance challenges grow with every capability increase

The healthiest mindset is: prepare for rapid progress without assuming any specific timeline for AGI. Build robust, well-governed systems that are useful at current capability levels, and design them to accommodate future improvements safely.

5.4 Common Misconceptions About the Future of AI

Misconception: "AI will replace all programmers within 5 years." Current coding agents solve about 50-60% of well-defined bugs in Python. They struggle with novel design, cross-cutting concerns, and ambiguous requirements. The developer's role is changing (more specification and review, less typing) but not disappearing. The analogy is not "cars replacing horses" but "power tools replacing hand tools": the carpenter's role changed, but carpenters still exist.

Misconception: "Open-source models will always lag behind proprietary ones." The gap between open-source and proprietary models has been narrowing, not widening. Models like Llama 3 and Mistral demonstrate competitive performance on many tasks. For agentic applications specifically, the model is only one component; tool design, prompting strategy, and system architecture matter as much or more. An open-source model with great tools can outperform a proprietary model with poor tools.

Misconception: "Agents will solve alignment by being smart enough." More capable agents are not automatically safer or more aligned. In fact, more capable agents are harder to align because they can find more creative ways to achieve goals that are slightly misspecified. A chess engine that can plan 20 moves ahead is harder to align with "play beautiful chess" than one that plans 5 moves ahead, because the more capable engine will find ugly but effective strategies that the simpler one would miss.

Misconception: "We can solve AI safety after we solve AI capability." Safety research needs to proceed in parallel with capability research, not after it. Once a highly capable but unsafe system exists, the damage may already be done. This is why organizations like Anthropic invest heavily in safety research alongside capability research, and why this course dedicates multiple weeks to safety and governance.

5.5 What Matters More Than the AGI Debate

Regardless of when or whether AGI arrives, several practical questions are more immediately important:

1. How do we build reliable agents? Current unreliability limits deployment. Improving reliability from 70% to 99% would transform the practical utility of agents.
2. How do we maintain human control? As agents become more capable, oversight becomes harder but more important. The automation paradox from Week 12 does not go away; it intensifies.
3. How do we distribute benefits fairly? AI-driven productivity gains should benefit broadly, not just those who build and deploy agents. How do we ensure that the economic benefits of AI are shared?
4. How do we manage the transition? Jobs, education, and institutions will change. How do we manage this transition humanely, ensuring that people who are displaced have paths to new opportunities?

Key Insight: The most important questions about agentic AI are not "when will AGI arrive?" but "how do we build systems that are reliable, safe, fair, and beneficial?" These are the questions that will determine whether agentic AI improves human life or creates new problems. Focus on the practical challenges, and the grand philosophical questions will take care of themselves.

---

086. Career Opportunities in Agentic AI

6.1 Technical Roles

Agent Engineer / AI Engineer. Designs, builds, and deploys agentic systems. Requires strong software engineering skills, understanding of LLMs and prompting, and experience with agent frameworks. This is the role most directly related to what you have learned in this course.

ML/AI Research Scientist. Conducts research on agent architectures, planning algorithms, memory systems, or alignment techniques. Typically requires a PhD or equivalent research experience. The open problems from Section 3 are your research agenda.

Safety and Alignment Researcher/Engineer. Focuses on making agents safe and aligned. A rapidly growing field with high demand and relatively few qualified candidates. If you found Week 11 the most interesting lecture, this might be your path.

Evaluation and Testing Engineer. Specializes in testing agentic systems: designing benchmarks, running evaluations, identifying failure modes. This role is critical for production deployment and is often undervalued.

MLOps / AI Platform Engineer. Builds the infrastructure that supports agent deployment: monitoring, logging, scaling, and lifecycle management. The observability and monitoring topics from Weeks 11 and 13 are directly relevant.

6.2 Interdisciplinary Roles

AI Product Manager. Defines what agents should do, working at the intersection of user needs, technical capabilities, and business requirements. Requires understanding of both technology and users.

AI Ethics and Governance Specialist. Ensures AI systems comply with regulations and ethical standards. Requires understanding of both technology and law/policy. Week 14's content is directly relevant.

Human-AI Interaction Designer. Designs the interfaces through which humans interact with agents. Combines UX design, cognitive science, and AI understanding. Week 12's content on agentic UX is your starting point.

AI Policy Advisor. Works with governments, organizations, or international bodies to develop AI policy. Requires understanding of both technology and governance.

6.3 Specific Role Descriptions

To make the career paths more concrete, here is what each role looks like in practice:

Agent Engineer / AI Engineer: What a typical week looks like. Monday: Debug a production agent that is failing to correctly call a new API endpoint. Trace the issue through logs and fix the tool description. Tuesday: Implement a new tool for the agent (database access with read-only safety constraints). Write tests. Deploy to staging. Wednesday: Review agent outputs from the past week. Identify patterns in failures. Update the system prompt to address recurring issues. Thursday: Design and implement a new guardrail for a customer-facing agent. Test with adversarial inputs. Friday: Write documentation for the team's CLAUDE.md patterns. Mentor a junior developer on agent-assisted development.

Salary range (US, 2026): $150K-$250K. The role is in high demand because it requires both strong software engineering skills and AI fluency, and few developers have both.

Safety and Alignment Researcher/Engineer: What a typical week looks like. Monday: Design and run a red-teaming exercise on a new agent deployment. Try to bypass guardrails through prompt injection. Tuesday: Analyze results from automated safety testing. Categorize failure modes. Write recommendations. Wednesday: Review academic papers on new alignment techniques. Present findings to the team. Thursday: Implement a new content filtering guardrail based on emerging threat patterns. Friday: Participate in an incident review meeting. A customer-facing agent produced inappropriate content; investigate root cause and propose fixes.

Salary range (US, 2026): $180K-$300K. Demand far exceeds supply. This is one of the fastest-growing roles in AI.

Evaluation and Testing Engineer: What a typical week looks like. Monday: Extend the agent evaluation suite with 50 new test cases based on real-world failures. Tuesday: Run the full benchmark suite against a new model version. Analyze regression results. Wednesday: Design a fairness evaluation for the hiring agent. Create controlled test inputs. Thursday: Build dashboards for monitoring agent performance metrics in production. Friday: Present evaluation results to the team. Recommend go/no-go for the new model version.

Salary range (US, 2026): $130K-$200K. Undervalued but increasingly recognized as critical.

6.4 Skills in Demand

Based on the landscape as of 2026:

1. Strong software engineering fundamentals. Agentic AI is software engineering. Data structures, algorithms, system design, distributed systems, and testing remain essential. The agent is built on top of a software system.
2. LLM fluency. Understanding how LLMs work, how to prompt them effectively, and how to integrate them into applications. This is the new literacy of AI engineering.
3. Systems thinking. Ability to design complex systems with many interacting components, reason about failure modes, and optimize across multiple objectives simultaneously.
4. Security mindset. Understanding threat models, attack vectors, and defense strategies. Prompt injection, data leakage, and unauthorized actions are the security challenges of the agent era.
5. Communication. Ability to explain AI capabilities and limitations to non-technical stakeholders. If you cannot explain what your agent does and what it cannot do, you cannot deploy it responsibly.
6. Ethical reasoning. Ability to identify and reason about the ethical implications of AI systems. This is not a nice-to-have; it is a professional requirement as regulations tighten.

6.4 Where to Start

Here is a concrete roadmap for getting started in each of these areas:

For agent engineering:

• Build a simple agent using a framework from Week 13 (start with OpenAI Agents SDK or Claude Agent SDK, which are the simplest)
• Add tools: file reading, web search, database access
• Add guardrails: input validation, output filtering, action constraints
• Deploy it (even locally) and monitor its behavior
• Try to break it with adversarial inputs; fix the issues you find

For research:

• Read the foundational papers referenced throughout this course (start with the ReAct paper by Yao et al. and the survey by Wang et al.)
• Follow conferences: NeurIPS, ICML, ACL, AAAI, and agent-focused workshops
• Reproduce a result from a paper; this teaches you far more than just reading
• Identify a limitation and propose an improvement; write it up even if you do not submit it

For open source:

• Contribute to projects like LangChain, LlamaIndex, OpenHands, or framework documentation
• Start small: fix bugs, improve documentation, add tests
• Open source is both a learning opportunity and a way to build a public portfolio

For community:

• Join forums, Discord servers, and meetups focused on AI engineering
• Write about what you learn: blog posts, tutorials, and research papers build reputation and deepen understanding
• Teaching is the best way to learn: explain a concept to someone else and you will understand it better yourself

Key Insight: The most successful people in this field are not necessarily the ones with the most knowledge. They are the ones who build things, share what they learn, and engage with the community. Knowledge without action is potential; action creates impact.

6.6 What to Learn Next: Concrete Learning Paths

Now that you have completed this course, here are four concrete learning paths depending on your interests:

Path 1: Becoming an Agent Engineer (3-6 months)

1. Build a complete agent application using Claude Agent SDK or OpenAI Agents SDK
2. Add MCP servers for database access, file operations, and web browsing
3. Implement comprehensive guardrails (input validation, output filtering, rate limiting)
4. Deploy the agent with monitoring and logging using Langfuse or similar
5. Write a blog post about what you built and what you learned
6. Resources: Anthropic's Claude documentation, OpenAI's Agents SDK docs, LangChain tutorials

Path 2: Becoming an AI Safety Researcher (6-12 months)

1. Read the foundational safety papers: "Constitutional AI" (Bai et al., 2022), "Sleeper Agents" (Hubinger et al., 2024), and the Anthropic safety research agenda
2. Reproduce a safety evaluation from a published paper
3. Design and run your own red-teaming exercise on a public model
4. Write up your findings (even informal blog posts count)
5. Apply to safety research internships at Anthropic, OpenAI, DeepMind, or MATS
6. Resources: Alignment Forum (alignmentforum.org), MATS program, ARC Evals

Path 3: Becoming an AI Product Manager (3-6 months)

1. Study successful AI products: how they balance capability with safety
2. Take a product management course that covers AI-specific considerations
3. Build a simple agent product (even a prototype) end-to-end
4. Practice writing product requirements documents (PRDs) for agentic features
5. Study the EU AI Act from a product perspective: what are the requirements for each risk level?
6. Resources: Lenny's Podcast (AI product episodes), "AI Product Management" courses on Coursera/edX

Path 4: Becoming an AI Governance Specialist (6-12 months)

1. Read the EU AI Act in full (it is publicly available)
2. Study the NIST AI RMF and ISO 42001 frameworks
3. Conduct a mock governance assessment of an AI system
4. Take a course on AI ethics or technology policy
5. Attend AI governance conferences and join working groups
6. Resources: OECD AI Policy Observatory, Future of Life Institute, EU AI Office publications

---

097. Ethical Responsibilities of Agentic AI Practitioners

7.1 The Practitioner's Burden

As builders of agentic AI systems, we bear a special responsibility. We create systems that act in the world, affecting people's lives, livelihoods, and well-being. This is not a responsibility that can be delegated to regulators, ethicists, or managers. It starts with the individual engineer making design decisions every day.

Honesty. Be honest about what your agents can and cannot do. Do not oversell capabilities or hide limitations. Marketing materials that claim "AI-powered, fully autonomous" when the system actually requires human oversight create false expectations that can lead to harm.

Diligence. Test thoroughly. Consider edge cases. Think about who might be harmed by your system's failures. The pre-mortem exercise from Week 11 should be a standard practice, not a one-time exercise.

Humility. Acknowledge uncertainty. You cannot predict all the ways your agent will be used or misused. Build in safeguards and monitoring. The systems we build are more complex than we can fully understand, and pretending otherwise is dangerous.

Advocacy. Advocate within your organization for adequate safety measures, even when they conflict with speed-to-market pressures. It is easier to push back before deployment than to apologize after an incident.

Inclusion. Consider the needs of diverse user populations. An agent that works well for English-speaking, technically literate users in wealthy countries but fails for others is not a complete solution. The world is diverse, and our agents should serve the world.

7.2 Ethical Frameworks in Practice

Several practical ethical frameworks can guide day-to-day decisions:

The newspaper test. Would you be comfortable if your design decision were reported on the front page of a newspaper? If not, reconsider.

The vulnerable user test. How would your agent affect the most vulnerable potential user? An elderly person with limited technology skills? A non-native speaker? Someone in a crisis? Design for them, and you protect everyone.

The reversibility test. Can the effects of your agent's actions be undone? If not, additional safeguards are needed. Irreversible actions deserve the highest level of scrutiny.

The transparency test. Can you explain what your agent does and why to a non-technical user? If not, the system may be too opaque to deploy responsibly.

7.3 A Responsible Development Manifesto

Based on everything we have learned in this course, here is a manifesto for responsible agentic AI development. These are not aspirational ideals; they are practical commitments that every practitioner can make.

1. I will be honest about my agent's capabilities. I will not market it as more capable than it is. I will document its limitations prominently, not hide them in fine print. When users ask what the agent can do, I will also tell them what it cannot do.

2. I will test before deploying. I will run adversarial tests, fairness audits, and reliability evaluations before any agent reaches users. I will not deploy first and test later.

3. I will design for failure. I will assume my agent will fail and build in graceful degradation, human fallback, and error recovery. An agent that fails catastrophically is worse than no agent at all.

4. I will keep humans in the loop. I will design human oversight that is genuine, not pro forma. The human overseer will have the information, authority, and tools to intervene effectively.

5. I will log everything. I will maintain comprehensive audit trails that enable root cause analysis when things go wrong and improvement over time.

6. I will respect privacy. I will minimize the personal data my agent accesses, anonymize where possible, and give users control over their data.

7. I will watch for bias. I will regularly audit my agent for differential treatment across demographic groups and take action when bias is found.

8. I will stay current. I will keep up with the evolving regulatory landscape, emerging safety research, and new best practices. What I know today will be partially outdated tomorrow.

9. I will speak up. When I see unsafe or unethical agent development in my organization, I will raise the concern, even when it is uncomfortable.

10. I will build for everyone. I will consider diverse users, including those with different abilities, languages, and technical backgrounds. An agent that works only for privileged users is not good enough.

This manifesto is a starting point, not a final word. The specific commitments will evolve as the field matures. But the underlying principle will not change: we are responsible for what we build.

7.4 The Broader Context

Agentic AI is not just a technology; it is a force that is reshaping society. As practitioners, we should be aware of the broader implications:

Labor displacement. Agents are already automating tasks previously performed by knowledge workers. While new opportunities are created, the transition can be painful for those displaced. This is not an argument against building agents; it is an argument for building them thoughtfully and supporting those affected by the transition.

Power concentration. AI agents can amplify the capabilities of their operators. If access to powerful agents is concentrated among a few organizations, this amplifies existing power imbalances. Supporting open-source AI, open standards, and broad access to agent technology helps counteract this concentration.

Epistemic effects. Agents that mediate our access to information shape what we know and believe. A research agent that consistently surfaces certain perspectives while ignoring others is not just a bad product; it is an epistemic hazard. Building agents that present diverse perspectives and flag uncertainty is a responsibility.

Environmental impact. Training and running large language models consumes significant energy. The environmental cost of agent infrastructure is real and should be considered in design decisions (e.g., using smaller models when they suffice, caching results, minimizing unnecessary computation).

Digital divide. As agentic AI becomes more integral to work and daily life, access to these tools becomes an equity issue. If powerful agents are available only to those who can afford expensive subscriptions, the productivity gap between those with and without agent access will widen. Supporting open-source agents, affordable pricing tiers, and public-interest applications helps address this divide.

Autonomy and dependency. As people become more reliant on AI agents for decision-making, there is a risk of losing the skills and confidence to make decisions independently. This is the individual version of the automation paradox from Week 12: the more the agent does for you, the less capable you become of doing it yourself. This is not an argument against using agents; it is an argument for maintaining human skills alongside agent use.

7.5 Ethical Dilemmas for Discussion

Consider these specific ethical scenarios. There is no single right answer; the value is in reasoning through the tradeoffs.

Scenario 1: The efficient but biased agent. Your hiring agent is 20% more efficient than human recruiters (faster screening, more consistent initial evaluation) but shows a 5% bias against candidates with non-Western names. You can deploy the biased agent (which is still more consistent than human recruiters, who show 8% bias) or not deploy it. What do you do?

Scenario 2: The helpful but invasive agent. A healthcare agent can predict patient deterioration 2 hours earlier than standard monitoring by combining medical records, activity data, and social media posts. The earlier prediction could save lives, but combining medical data with social media raises serious privacy concerns. How do you balance the benefit against the privacy cost?

Scenario 3: The autonomous military agent. You are offered a high-paying job building autonomous targeting systems for a military contractor. The systems will have human oversight (a human approves every engagement). Do you take the job? Does the human oversight change your answer? What if the oversight is "human-on-the-loop" rather than "human-in-the-loop"?

These scenarios illustrate that ethical questions in agentic AI are not abstract philosophical puzzles; they are practical decisions that real practitioners face. Thinking about them now prepares you for when you face them in your career.

Try It Yourself: Your Personal Ethics Framework

Write a one-page personal ethics framework for your work in AI. It should include:

1. Three things you will always do (e.g., "I will always test for bias before deploying any agent that makes decisions about people")
2. Three things you will never do (e.g., "I will never deploy an agent in a safety-critical domain without human oversight")
3. Three things where you are uncertain (e.g., "I am uncertain about whether agents should be used for content moderation at scale")

For each item, explain your reasoning. This document is for you, not for evaluation. Having thought through your positions before you face the decision makes it much easier to act ethically when the pressure is on.

The fact that you are uncertain about some things is a sign of intellectual honesty, not weakness. The field is too new and too complex for anyone to have all the answers. What matters is that you have thought about the questions.

---

108. Integration Exercise: Design a Complete Agent System

This exercise brings together concepts from across the entire course. Work through it as a capstone review.

8.1 The Scenario

You are tasked with designing an AI agent system for a medium-sized law firm (50 lawyers, 200 support staff). The system should assist lawyers with legal research, document drafting, case analysis, and client communication management.

8.2 Design Questions

Work through the following questions, applying concepts from the specified weeks:

Architecture (Weeks 1, 5):

• What agent architecture would you use? (ReAct, Plan-and-Execute, multi-agent?)
• Would you use a single agent or multiple specialized agents?
• What is the observe-think-act loop for this agent?

Model Selection (Weeks 2-3):

• What model(s) would you use? Consider the tradeoff between capability and cost.
• What prompting strategy would you use? Write a sample system prompt.
• How would you handle the model's knowledge cutoff for recent case law?

Tools (Weeks 4-5):

• What tools does the agent need? (Legal databases, document management, calendar, email)
• Design tool descriptions for three key tools.
• How would you use MCP to standardize tool access?

Memory (Weeks 6-7):

• What types of memory does the agent need? (Case history, client preferences, legal precedents)
• How would you implement long-term memory for client relationships?
• How would you use RAG for legal research?

Planning (Week 9):

• How would the agent plan a complex legal research task?
• What decomposition strategy would you use for drafting a legal brief?

Multi-Agent (Week 8):

• Would you use multiple specialized agents? If so, what specializations?
• How would agents communicate about a shared case?

Evaluation (Week 10):

• How would you evaluate the agent's legal research quality?
• What metrics would you track?
• How would you handle the subjective nature of "good" legal advice?

Safety (Week 11):

• What guardrails would you implement? (Legal advice disclaimers, confidentiality)
• How would you prevent the agent from giving incorrect legal advice?
• What is your pre-mortem for this system?

Human Oversight (Week 12):

• What oversight paradigm? (HITL, HOTL, or hybrid)
• Which actions require lawyer approval?
• How would you handle the automation paradox?

Software Engineering (Week 13):

• How would you build and deploy this system?
• What testing strategy would you use?
• How would you use coding agents to build the system itself?

Governance (Week 14):

• What risk category under the EU AI Act?
• What audit trail requirements?
• What data privacy considerations (attorney-client privilege)?
• What liability framework?

8.3 Discussion

There is no single correct answer to this exercise. The value is in the design process: identifying the tradeoffs, making deliberate choices, and justifying those choices based on the principles from this course. Compare your design with a classmate's and discuss where you differ and why.

Key Insight: This exercise demonstrates that building a real-world agentic system requires mastery of ALL the course material, not just the technical layers. The legal domain makes governance and safety particularly critical, but the same is true for any high-stakes domain. A capable agent without proper governance is a liability; a well-governed agent without capability is useless. The art is in the balance.

---

119. Final Reflections

9.1 What We Have Learned

This course has covered the full spectrum of agentic AI: from the foundations of large language models to the governance of autonomous systems. We have built a conceptual toolkit that includes:

• Technical knowledge: How agents work, from model architecture to system design, from prompting to multi-agent coordination
• Engineering skills: How to build, test, deploy, and monitor agents safely and reliably
• Critical thinking: How to evaluate agent capabilities honestly, identify limitations, and reason about risks
• Ethical awareness: How to build agents that serve human well-being, comply with regulations, and respect rights

9.2 The Field Is Young

Agentic AI as a field is remarkably young. The foundational papers are just a few years old. The tools and frameworks are evolving monthly. The standards and regulations are being written in real time. This means three things:

You are not behind. Everyone is learning. There are no deep experts with decades of experience because the field did not exist decades ago. If you have completed this course, you have a solid foundation that many working professionals lack.

You can contribute. The field needs diverse perspectives: not just ML researchers but software engineers, product designers, ethicists, domain experts, and users. Whatever your background, there is a place for you. Some of the most impactful contributions to agentic AI have come from people outside traditional AI research: software engineers who built better tools, UX designers who created better interfaces, legal scholars who identified governance gaps, and domain experts who identified the most valuable applications.

Things will change. What we covered in this course will be partially outdated within a year. The specific tools, techniques, and best practices will evolve. But the principles will endure: the observe-think-act loop, the importance of grounding, the need for safety, the role of human oversight, the ethical responsibilities. Learn how to learn, and stay current.

Here is what will likely remain true regardless of how the field evolves:

• Agents will still need tools to interact with the world
• Memory and context management will still be fundamental challenges
• Safety will still require deliberate design, not just hope
• Humans will still need to oversee agents, especially in high-stakes domains
• Evaluation will still be harder than building
• The ethical questions will still matter

9.3 What Will Be Different in One Year

If history is any guide, the landscape of agentic AI one year from now will be substantially different from today. Here are predictions you can test against reality:

Models will be more capable. The foundation models will be better at reasoning, planning, and tool use. Tasks that require human review today may be reliable enough for automation.

Safety will lag capability. Capability improvements tend to outpace safety improvements. New capabilities will create new risks that existing guardrails do not address.

Regulation will be more concrete. The EU AI Act's high-risk requirements will be in full effect. Concrete enforcement actions will begin to shape how organizations approach compliance.

Multi-modal agents will be common. Agents that combine text, vision, audio, and tool use will move from research prototypes to production systems.

The tool ecosystem will mature. MCP and similar standards will become more established. The ecosystem of tools available to agents will grow significantly.

Some of what we taught will be wrong. Some of the best practices from this course will be superseded by better approaches. Some of the limitations we discussed will be partially solved. This is the nature of a fast-moving field. The principles will endure; the specifics will evolve.

9.4 A Personal Note

Building agentic AI systems is one of the most intellectually stimulating and consequential activities in technology today. You have the opportunity to shape how these systems are built, deployed, and governed. Take that responsibility seriously, but also enjoy the journey. The problems are fascinating, the pace of progress is exhilarating, and the potential for positive impact is enormous.

Build things that matter. Build them carefully. Build them for everyone.

9.5 Recommended Reading for Continued Learning

If you want to go deeper after this course, here are the ten most important papers and resources to read next:

1. Yao et al. (2023), "ReAct" -- The foundational paper on reasoning and acting in language models. Start here.
2. Wang et al. (2024), "A Survey on LLM-Based Autonomous Agents" -- Comprehensive survey of the field.
3. Shinn et al. (2023), "Reflexion" -- Self-reflection and verbal reinforcement learning for agents.
4. Bai et al. (2022), "Constitutional AI" -- The alignment approach behind Claude. Essential for safety.
5. Anthropic (2025), "Claude Code Documentation" -- Practical guide to the most capable coding agent.
6. European Union (2024), "AI Act" -- The full text of the regulation. Dense but essential.
7. NIST (2023), "AI Risk Management Framework" -- Practical guidance for AI governance.
8. Lee and See (2004), "Trust in Automation" -- Foundational human factors paper. Still relevant.
9. Jimenez et al. (2024), "SWE-bench" -- Understanding how coding agents are evaluated.
10. Lilian Weng (2023), "LLM-Powered Autonomous Agents" -- Excellent blog post overview of the field.

---

129. Final Exam Review: Key Concepts From Each Week

This section provides a concise review of the most important concepts from each week. Use it as a study guide and a checklist for your own understanding.

Week 1: Introduction to AI Agents

• Core concept: An agent is a system that perceives its environment, reasons about it, and takes action, in a loop.
• Key distinction: Agents vs. chatbots. Chatbots generate text; agents take action.
• Must-know: The observe-think-act cycle. Environment, tools, and the agent loop.
• Test yourself: Can you explain why a search engine is NOT an agent, but a system that automatically searches, reads results, and decides what to search next IS an agent?

Week 2: LLMs as Reasoning Engines

• Core concept: LLMs provide the "brain" of modern agents through next-token prediction.
• Key distinction: Transformer architecture, attention mechanism, context window.
• Must-know: How temperature affects output. What the context window means for agents. Why LLMs hallucinate.
• Test yourself: Can you explain why a larger context window matters for agents but not as much for simple chatbots?

Week 3: Prompting Strategies

• Core concept: Prompting is the primary interface for controlling agent behavior.
• Key techniques: Zero-shot, few-shot, chain-of-thought, system prompts.
• Must-know: How to write effective system prompts for agents. Why chain-of-thought improves reasoning.
• Test yourself: Can you convert a poorly specified task into a well-structured prompt?

Week 4: Tool Use and MCP

• Core concept: Tools are what transform a language model into an agent that can act in the world.
• Key techniques: Function calling, tool descriptions, parameter schemas, MCP.
• Must-know: How to define a tool with a good description that the model can understand. What MCP is and why it matters.
• Test yourself: Can you design a tool definition (name, description, parameters) for a new API endpoint?

Week 5: Agent Architectures

• Core concept: Different architectures (ReAct, LATS, Plan-and-Execute) make different tradeoffs.
• Key distinction: Reactive agents (respond to input) vs. deliberative agents (plan ahead).
• Must-know: The ReAct pattern (Reason + Act). When to use plan-and-execute vs. reactive.
• Test yourself: Can you explain the tradeoffs between a ReAct agent and a Plan-and-Execute agent?

Week 6: Memory Systems

• Core concept: Memory enables agents to persist information across interactions and learn over time.
• Key types: Working memory (current context), episodic memory (past experiences), semantic memory (knowledge).
• Must-know: How context window limitations drive memory architecture decisions.
• Test yourself: Can you design a memory system for a personal assistant agent?

Week 7: RAG for Agents

• Core concept: Retrieval-Augmented Generation grounds agent responses in external knowledge.
• Key techniques: Chunking, embedding, vector search, reranking.
• Must-know: The RAG pipeline. Why retrieval quality is the bottleneck. Common chunking strategies.
• Test yourself: Can you diagnose why a RAG system returns irrelevant results?

Week 8: Multi-Agent Systems

• Core concept: Multiple agents can collaborate to solve problems beyond any single agent's capability.
• Key patterns: Supervisor, debate, pipeline, swarm.
• Must-know: When multi-agent systems help and when they add unnecessary complexity.
• Test yourself: Can you design a multi-agent system for a specific task and justify the architecture?

Week 9: Planning and Decomposition

• Core concept: Complex tasks require explicit planning, decomposition, and reflection.
• Key techniques: Task decomposition, search-based planning, self-reflection.
• Must-know: Why agents struggle with long-horizon tasks. How reflection improves plan quality.
• Test yourself: Can you decompose a complex task into a plan and identify where things might go wrong?

Week 10: Evaluation and Benchmarking

• Core concept: Evaluating agents is fundamentally harder than evaluating models.
• Key benchmarks: SWE-bench, WebArena, GAIA, TAU-bench.
• Must-know: Why pass/fail metrics are insufficient. How to design meaningful evaluations.
• Test yourself: Can you design an evaluation framework for a customer service agent?

Week 11: Safety, Alignment, and Guardrails

• Core concept: Safety is not an add-on; it is a core design requirement.
• Key techniques: Input/output guardrails, content filtering, sandbox execution, defense in depth.
• Must-know: Prompt injection (direct and indirect). Why alignment is hard. The pre-mortem exercise.
• Test yourself: Can you identify three ways an attacker could misuse a given agent?

Week 12: Human-Agent Interaction

• Core concept: Human oversight is essential, but effective oversight requires deliberate design.
• Key patterns: HITL, HOTL, fully autonomous. Approval workflows. Trust calibration.
• Must-know: The automation paradox. Progressive autonomy. Anti-rubber-stamping measures.
• Test yourself: Can you design an appropriate oversight level for a specific agent deployment?

Week 13: Agentic Software Engineering

• Core concept: Coding agents represent Stage 4 of AI-assisted programming: closed-loop, multi-step, environment-aware.
• Key tools: Claude Code, Cursor, Copilot, Devin, OpenHands.
• Must-know: SWE-bench scores. Prompt engineering for coding agents. Security risks.
• Test yourself: Can you write an effective prompt for a coding agent to fix a specific bug?

Week 14: Governance and Trustworthy AI

• Core concept: Governance ensures agents are deployed responsibly within legal and ethical frameworks.
• Key frameworks: EU AI Act risk categories, NIST AI RMF, ISO 42001.
• Must-know: High-risk classification criteria. Audit trail requirements. The accountability gap.
• Test yourself: Can you classify an agent under the EU AI Act and list its governance requirements?

Cross-Cutting Concepts That Span Multiple Weeks

These concepts appear repeatedly and are the most important to understand deeply:

The observe-think-act loop (Weeks 1, 5, 9, 13). This is the foundational pattern. Everything else in the course is about making this loop more capable (tools, memory, planning), more reliable (evaluation, testing), and more safe (guardrails, oversight, governance). If you understand this loop deeply, you understand agentic AI.

Grounding (Weeks 4, 7, 11). The difference between generating plausible text and taking correct action. Tools ground agents in reality (Week 4). RAG grounds agents in external knowledge (Week 7). Safety guardrails ground agents in acceptable behavior (Week 11). Without grounding, agents are confident but unreliable.

The capability-safety tradeoff (Weeks 5, 8, 11, 14). Every increase in capability creates new risks. More tools mean more ways to cause harm. More autonomy means less oversight. More intelligence means more effective pursuit of misspecified goals. Understanding this tradeoff is essential for responsible development.

Progressive autonomy (Weeks 2, 12, 14). The principle that autonomy should be earned through demonstrated competence, not assumed. Start with high oversight, reduce as trust is established, increase again if trust is violated. This applies to individual agents, organizational deployment, and regulatory frameworks.

The human role (Weeks 12, 14, 15). Humans remain essential as designers, overseers, evaluators, and decision-makers. The question is not whether humans are needed but how to design their role effectively. The automation paradox is the central challenge: making human oversight effective when the system is too reliable to keep humans engaged.

Try It Yourself: Self-Assessment Quiz

Answer these ten questions without looking at the notes. Then check your answers and identify your weakest areas for further study.

1. What are the three components of the observe-think-act loop?
2. Name three types of memory in an agent system and give an example of each.
3. What is the difference between ReAct and Plan-and-Execute architectures?
4. What is prompt injection, and why is it fundamentally hard to prevent?
5. What is the automation paradox, and how does it affect human oversight?
6. What is SWE-bench, and what do current scores tell us about agent capabilities?
7. Under the EU AI Act, what makes an AI system "high-risk"?
8. What is the difference between demographic parity and equalized odds?
9. Name three anti-rubber-stamping measures for approval workflows.
10. What is the difference between an agent at Level 3 autonomy and Level 4?

If you can answer 8 or more correctly with specific detail, you have a strong grasp of the course material. If fewer than 6, revisit the relevant weeks.

---

1310. Comprehensive Review for Final Project Presentations

10.1 What to Prepare

For your final project presentation, you should be able to:

1. Describe your agent's architecture. Map your system to the agentic AI stack. Which layers does your agent use? What choices did you make at each layer and why?

2. Demonstrate your agent's capabilities. Show your agent performing its intended task. Highlight where it works well and where it struggles. Honest demonstration of limitations is valued more than hiding them.

3. Discuss safety and limitations. What guardrails did you implement? What are the known failure modes? How would your agent handle adversarial inputs?

4. Explain your evaluation approach. How did you test your agent? What metrics did you use? What were the results?

5. Reflect on lessons learned. What surprised you? What would you do differently? What did you learn about building agentic systems that you did not expect?

10.2 Review Checklist

Use this checklist to ensure your project covers the key concepts from the course:

Foundations (Weeks 1-4):

• Agent definition and architecture clearly articulated
• Appropriate model selection and prompting strategy
• Understanding of model capabilities and limitations

Capabilities (Weeks 5-7):

• Meaningful tool integration (not just a wrapper around an API)
• Appropriate use of retrieval if the task requires external knowledge
• Memory strategy (even if ephemeral, justify the choice)

Intelligence (Weeks 8-10):

• Planning approach for multi-step tasks
• Evaluation methodology with meaningful metrics
• (If applicable) Multi-agent coordination

Responsibility (Weeks 11-14):

• Safety measures: at minimum input validation and output filtering
• Human oversight: mechanism for human review or intervention
• Error handling: graceful degradation when things go wrong
• Documentation: clear description of what the agent does and its limitations

10.3 Common Pitfalls in Final Projects

Based on past experience, here are the most common pitfalls in final project presentations and how to avoid them:

Pitfall 1: Demo-only presentations. Showing a demo without explaining the architecture. The demo shows what the agent does but not how or why. Always explain the design decisions, not just the capabilities.

Pitfall 2: Ignoring failures. Presenting only the cases where the agent works well. Evaluators are more impressed by honest discussion of failure modes than by cherry-picked successes. Show where the agent fails, explain why, and describe what you would do about it.

Pitfall 3: No evaluation. Building an agent without any systematic evaluation. Even a small evaluation (20 test cases with clear pass/fail criteria) is vastly better than none. "We tried it and it seemed to work" is not evaluation.

Pitfall 4: Missing safety discussion. Building a capable agent without discussing safety. Every agent has failure modes. Every agent can be misused. Discuss what could go wrong and what you did (or would do) about it.

Pitfall 5: Overcomplicating the architecture. Using multi-agent systems, complex memory architectures, and sophisticated planning when a simple ReAct agent with two tools would suffice. The best architecture is the simplest one that solves the problem.

Pitfall 6: Not acknowledging the model's contribution. Claiming "my agent can do X" when in reality "the LLM can do X and my agent wraps it." Be clear about what your system adds beyond the base model.

10.4 Evaluation Criteria

Projects will be evaluated on:

---

1411. Discussion Questions

1. The course in hindsight. Now that you have completed the course, what topic do you wish we had covered in more depth? What topic was less useful than expected?

2. The most important lesson. What is the single most important thing you learned in this course? How will it influence your future work?

3. Predictions. Make three specific, falsifiable predictions about where agentic AI will be in 5 years (2031). What capabilities will agents have? What will remain unsolved? What will surprise us?

   Hint: Good predictions are specific. "AI will be more powerful" is not specific. "Coding agents will solve 90%+ of SWE-bench Verified" is specific and falsifiable. Write your predictions down; revisit them in 5 years.

4. The responsibility question. As someone who now knows how to build AI agents, what ethical guidelines will you set for yourself in your career? Where would you draw the line on what you would or would not build?

   Hint: Think about specific scenarios, not abstract principles. Would you build an agent that automates hiring decisions? Content moderation? Military applications? Political advertising? Where is your personal line, and why?

5. The future of CS education. How should computer science education change to prepare students for a world where AI agents are ubiquitous? Should programming remain a core skill, or will it be partially replaced by "agent orchestration" skills?

   Hint: Consider that the skills most valuable in an AI-augmented world may not be the same as those most valuable today. What skills become more important? What skills become less important?

6. The biggest open problem. Of the six open research problems discussed in Section 3 (reliability, long-horizon tasks, reasoning depth, robust tool use, safety, and evaluation), which do you think is the most important to solve? Which is the hardest? Which will be solved first?

   Hint: The most important, the hardest, and the one solved first may be three different problems. Think about which problem is the biggest barrier to practical deployment (important), which requires the deepest conceptual breakthrough (hard), and which is most tractable with current approaches (solvable soon).

7. Build vs. buy. An organization wants to deploy an AI agent for internal knowledge management. Should they build a custom agent, use an off-the-shelf agent platform, or use a general-purpose AI assistant (like Claude or ChatGPT) with custom configuration? What factors should drive this decision?

   Hint: Consider the tradeoffs: customization vs. maintenance burden, capability vs. cost, speed to deployment vs. long-term flexibility. Consider the organization's technical capacity, the sensitivity of the data, and the specificity of the requirements.

8. The "killer app" question. What is the "killer app" for agentic AI? That is, what application would be so valuable that it would drive mainstream adoption of agentic AI the way spreadsheets drove adoption of personal computers?

   Hint: Think about tasks that are currently extremely expensive, tedious, or impossible without AI agents. Consider both consumer and enterprise applications. The killer app might not be a single application but a capability that transforms many applications.

---

1512. Summary and Key Takeaways

1. The agentic AI stack comprises eight layers: fundamentals, foundation models, tools and actions, memory and state, planning and reasoning, multi-agent coordination, human interaction, and governance. Each layer contributes essential capabilities, and they interact bidirectionally. The most common architectural mistake is investing in capability layers without adequate investment in safety and governance layers.

2. The course followed a deliberate progression from foundations through capabilities, intelligence, and responsibility. Key themes throughout: the capability-safety tradeoff, the importance of grounding, the essential human role, and the engineering challenge of building reliable systems.

3. Current limitations include unreliability, difficulty with long-horizon tasks, shallow reasoning, brittle tool use, incomplete safety, and inadequate evaluation. Each of these is an active research area with high practical importance.

4. Emerging trends include autonomous scientific discovery, agentic robotics, AI-native software, personalized long-term agents, and agent ecosystems with marketplaces and interoperability standards.

5. The path to AGI is uncertain. Current agents are extraordinarily capable but fundamentally limited in understanding, novel reasoning, and self-improvement. Practical challenges (reliability, safety, fairness, human oversight) are more immediately important than the AGI timeline debate.

6. Career opportunities span technical roles (agent engineering, safety research, evaluation), interdisciplinary roles (product management, ethics, policy), and require a combination of software engineering fundamentals, LLM fluency, systems thinking, and ethical reasoning.

7. Ethical responsibilities include honesty about capabilities, diligence in testing, humility about uncertainty, advocacy for responsible practices, and attention to the broader societal effects of AI (labor displacement, power concentration, epistemic effects, environmental impact).

8. The final exam review covers key concepts from each week, with self-test questions to verify understanding. Use it as a study guide and identify any gaps in your knowledge.

9. Concrete learning paths exist for agent engineering, safety research, AI product management, and AI governance. Each requires 3-12 months of focused effort and builds on the foundation from this course.

10. The responsible development manifesto provides ten practical commitments for ethical agent development: honesty about capabilities, testing before deployment, designing for failure, genuine human oversight, comprehensive logging, privacy respect, bias monitoring, staying current, speaking up, and building for everyone.

11. The field is young. You are entering at the ground floor. The principles from this course will endure; the specific tools and techniques will evolve. Stay curious, stay responsible, and build things that matter.

---

1613. References

• Ahn, M., Brohan, A., Brown, N., Chebotar, Y., Cortes, O., David, B., ... & Zeng, A. (2022). Do as I can, not as I say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691.

• Boiko, D. A., MacKnight, R., Kline, B., & Gomes, G. (2023). Autonomous chemical research with large language models. Nature, 624, 570-578.

• Brohan, A., Brown, N., Carbajal, J., Chebotar, Y., Chen, X., Choromanski, K., ... & Zitkovich, B. (2023). RT-2: Vision-language-action models transfer web knowledge to robotic control. arXiv preprint arXiv:2307.15818.

• Bubeck, S., Chandrasekaran, V., Eldan, R., Gehrke, J., Horvitz, E., Kamar, E., ... & Zhang, Y. (2023). Sparks of artificial general intelligence: Early experiments with GPT-4. arXiv preprint arXiv:2303.12712.

• Park, J. S., O'Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., & Bernstein, M. S. (2023). Generative agents: Interactive simulacra of human behavior. Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (UIST), 1-22.

• Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., & Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems, 36.

• Wang, L., Ma, C., Feng, X., Zhang, Z., Yang, H., Zhang, J., ... & Wang, J. (2024). A survey on large language model based autonomous agents. Frontiers of Computer Science, 18(6), 186345.

• Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., ... & Zhou, D. (2022). Chain-of-thought prompting elicits reasoning in large language models. Advances in Neural Information Processing Systems, 35.

• Weng, L. (2023). LLM-powered autonomous agents. Lil'Log (blog post). https://lilianweng.github.io/posts/2023-06-23-agent/

• Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2023). ReAct: Synergizing reasoning and acting in language models. Proceedings of the 11th International Conference on Learning Representations (ICLR 2023).

---

These lecture notes are part of the Agentic AI course. Licensed under CC BY 4.0.