Question 1

What problem does Agentic AI solve that a regular LLM can't?

Accepted Answer

A plain LLM call is stateless and single-shot you give it a prompt, it gives you text back, and it has no way to check whether that text actually solved your problem.
- It can't look anything up, take an action, or try again if it's wrong.
- Agentic AI solves this by wrapping the model in a loop: the system can call tools, observe results, and keep iterating until the actual goal not just a plausible-sounding answer is achieved.

Example: Ask an LLM "what's the cheapest flight to Delhi tomorrow" and it will guess based on training data or say it can't know. An agentic system will call a live flights API, compare real prices and give you an answer that's actually correct today.

Question 2

How does Agentic AI differ from traditional AI?

Accepted Answer

Traditional AI reacts to input or follows fixed rules. Agentic AI adds planning, reasoning, tool use and memory, so it can take initiative and complete multi-step tasks unsupervised.

Traditional AI
- Traditional AI is designed to perform specific tasks such as prediction, classification, recommendation, or automation.
- It follows predefined rules or learned patterns to generate outputs.
- It typically responds to a single input without independently planning future actions.
- It requires user intervention for each new task or decision.
- It is commonly used in spam detection, recommendation systems, fraud detection, and image classification.
- Goal: Solve a specific problem or automate a well-defined task.

Agentic AI
- Agentic AI is designed to autonomously plan, reason, and execute multi-step tasks.
- It can break complex goals into smaller tasks and decide the sequence of actions needed.
- It interacts with external tools, APIs, databases, and software systems to complete tasks.
- It adapts its actions based on intermediate results and feedback.
- It requires minimal user intervention after the goal is specified.
- Goal: Achieve a user-defined objective by reasoning, planning,

Question 3

What's the difference between AI Agent vs Agentic AI?

Accepted Answer

AI Agent and Agentic AI are closely related but not the same. An AI agent is a building block; Agentic AI is the overall system architecture.

AI Agent
- An AI Agent is a software entity that performs specific tasks on behalf of a user or system.
- It perceives its environment, processes information, and takes actions to achieve a defined objective.
- It can use tools, APIs, databases, or other software to complete tasks.
- It is usually designed for a particular domain or workflow.
- Multiple AI agents can work together to solve complex problems.
- Goal: Complete a specific task or objective autonomously.

Agentic AI
- Agentic AI is a broader AI paradigm that emphasizes autonomous reasoning, planning, and decision-making.
- It enables AI systems to break complex goals into smaller tasks, adapt to changing conditions, and execute multi-step workflows.
- It often consists of one or more AI agents working together with memory, planning, and tool usage.
- It can continuously evaluate progress and modify its actions based on feedback.
- It is used to build highly autonomous systems capable of achieving complex goals.
- Goal: Build AI systems that can independently reason, plan, and acc

Question 4

What's the difference between Agentic AI vs Generative AI?

Accepted Answer

Generative AI creates content from a prompt. Agentic AI achieves goals by reasoning, planning and acting, often using a generative model as its "brain."

Generative AI
- Generative AI is designed to create new content such as text, images, audio, videos, and code.
- It generates responses based on patterns learned from large training datasets.
- It typically responds to user prompts without independently planning multiple actions.
- It is widely used for content generation, summarization, translation, image generation, and code generation.
- Examples include ChatGPT for text generation and image generation models like DALL·E.
- Goal: Generate high-quality and contextually relevant content.

Agentic AI
- Agentic AI is designed to autonomously plan, reason, and perform multi-step tasks to achieve a goal.
- It can make decisions, use tools, interact with external systems, and adapt its actions based on feedback.
- It breaks complex problems into smaller tasks and executes them sequentially.
- It often integrates LLMs with tools, APIs, databases, memory, and planning mechanisms.
- It is widely used for AI assistants, workflow automation, software development agents, and research assist

Question 5

What are the different types of AI agents?

Accepted Answer

Classified by how much reasoning and memory they use:
- Simple reflex agents: Act on current input only, using fixed rules, no memory.
- Model-based reflex agents: Keep an internal world model to handle partial information.
- Goal-based agents: Choose actions that move toward a specific goal.
- Utility-based agents: Pick the action that maximizes a "utility" score among valid options.
- Learning agents: Improve over time from feedback.

Question 6

What are the primary components of AI agents?

Accepted Answer

An AI agent generally consists of five main components:
1. Memory: It helps the agent recall past actions, user preferences and context.
2. Reasoning Engine: This part decides what the agent should do next based on logic or goals.
3. Tool Use: Agents use APIs, databases or other services to perform specific actions.
4. Communication Layer: Enables interaction with users and other systems.
5. Environment Interface: Allows agents to perceive and modify their surroundings.

Question 7

Why is memory critical for the performance of AI agents?

Accepted Answer

Memory gives an agent context, continuity and the ability to learn — without it, every query is treated as a brand-new conversation.
- Short-term memory: Context within one conversation/task.
- Long-term memory: Persistent knowledge, often in a vector database.
- Working memory: Supports reasoning during a multi-step task.

Example: An assistant with memory recalls you prefer meetings after 2 PM and applies that automatically next time.

Question 8

What's the difference between Agentic System vs User Prompt?

Accepted Answer

An Agentic System is an AI system that autonomously plans, reasons, and executes tasks to achieve a goal, whereas a User Prompt is the instruction or query provided by the user that tells the AI what to do.

Agentic System
- An Agentic System is an AI system capable of reasoning, planning, and executing multi-step tasks autonomously.
- It can break a complex goal into smaller tasks and determine the sequence of actions.
- It can use external tools, APIs, databases, memory, and search engines to complete tasks.
- It adapts its actions based on intermediate results and feedback.
- It requires minimal user intervention after receiving the objective.
- Goal: Achieve a user-defined objective through autonomous planning and execution.

User Prompt
- A User Prompt is the input, instruction, or question given by the user to an AI model.
- It specifies what the user wants the AI to do or answer.
- It serves as the starting point for the AI's response or task execution.
- The quality and clarity of the prompt influence the quality of the AI's output.
- It does not perform reasoning or actions by itself; it only provides guidance to the AI.
- Goal: Communicate the user's intent or request to

Question 9

What are tools in the context of Agentic AI?

Accepted Answer

In Agentic AI, tools refer to external functions, APIs or software utilities that an AI agent can call to perform actions beyond simple text generation. They allow the agent to interact with the real world, execute commands, retrieve live data and complete complex workflows.
- Searching the web for current information.
- Querying a database to fetch or update records.
- Running code for analysis.
- Sending an email or calendar invite.

This mechanism where the model invokes a function with structured arguments is called function/tool calling.

Question 10

Common frameworks for building Agentic AI systems?

Accepted Answer

Frameworks provide ready-made building blocks for planning, memory and tool orchestration instead of writing an agent loop from scratch.
- LangChain: Chains reasoning steps, integrates tools.
- LlamaIndex: Connects models to structured/unstructured data.
- CrewAI / AutoGen: Multi-agent collaboration.
- ReAct: A prompting pattern that interleaves reasoning with action, not a full framework.

Question 11

What is an AI agent, and how does it differ from a simple LLM call?

Accepted Answer

A simple LLM call is a single, stateless input→output: text in, text out, no actions. An AI agent is an LLM placed in a loop with tools, memory, and autonomy — it reasons about a goal, decides which action to take, executes it, observes the result, and repeats until done. The defining property is agency: it chooses its next step based on feedback rather than following a fixed script.

LLM call: prompt → response | Agent: goal → [reason → act → observe] loop → result

What turns an LLM into an agent:
- Tools: ability to act on the world (search, DB, code, APIs).
- Loop/control: iterate over multiple steps toward a goal.
- Memory/state: carry context across steps.
- Autonomy: the model, not hard-coded logic, decides what to do next.

One-liner: "An LLM call answers a question. An agent accomplishes a goal — it plans, uses tools, and adapts across steps. Agent ≈ LLM (reasoning) + tools (acting) + memory (state) + a control loop."

Question 12

What is tool use (function calling) in LLMs, and how does it enable agents?

Accepted Answer

Function calling is a capability where you describe tools to the model as schemas (name + typed JSON parameters), and the model, instead of answering in prose, outputs a structured call — the tool name and arguments. Your code executes it and returns the result to the model. This is the mechanism that lets an LLM act, which is what makes agents possible.

Model outputs: {tool:"get_weather", args:{"city":"Delhi"}} → your code runs it → result fed back → model continues

Why it's foundational:
- Grounding: fetch fresh/exact data instead of hallucinating.
- Offloading: delegate what LLMs are bad at (math, lookups, precise ops) to reliable tools.
- Action: take real-world effects — send email, query DB, run code.

Key nuance: The model doesn't execute anything — it only emits a structured request; your runtime executes and returns the observation. That separation is where permissions, validation, and sandboxing live. (This request→execute boundary is the heart of agent harnesses.)

Question 13

How do you design and define tools for an AI agent?

Accepted Answer

Design tools the way you'd design a clean API for an LLM to read. The model selects and calls tools based entirely on their names, descriptions, and parameter schemas — so those are your control surface. Make them clear, atomic, and minimal.

Principles:
- Precise descriptions: the description is how the model decides when to use a tool — this is the #1 driver of correct selection.
- Typed schema with per-parameter descriptions (and examples) so the model fills args correctly.
- Atomic & single-purpose: one clear job per tool; avoid overlapping tools that confuse selection.
- Minimal set: fewer, well-scoped tools beat a sprawling toolbox (too many → wrong picks).
- Informative errors: return actionable error messages so the model can self-correct.
- Safety by design: scope permissions; gate destructive tools.

Direct to your work: Tool/skill design and loading is exactly the harness layer — clear schemas + curated tool sets are what make an agent reliably pick and call the right thing. (Prakhar's Rowboat skill-loading infra lives right here.)

Question 14

What is the difference between reactive and proactive agents?

Accepted Answer

A reactive agent responds to inputs/events as they arrive — stimulus → response. A proactive agent anticipates and initiates: it pursues goals, plans ahead, and takes action without being explicitly prompted each time (e.g. monitoring a system and acting when a condition arises).

Reactive vs Proactive:
- Trigger — Reactive: External input/event. Proactive: Internal goals, schedules, monitoring.
- Behavior — Reactive: Answers/executes on request. Proactive: Anticipates, initiates, plans.
- Example — Reactive: Chatbot answering a query. Proactive: Agent that watches metrics and alerts/fixes.

Most deployed agents today are reactive. Proactive agents add goal-tracking, scheduling/triggers, and initiative — powerful but higher-risk (they act without a human in the immediate loop), so they need stronger guardrails.

Framing: "Reactive = respond; proactive = initiate. Proactivity unlocks autonomy but raises the stakes — an agent taking unprompted actions needs tighter permissions and monitoring than one that only answers."

Question 15

What is the difference between code-generating agents and tool-calling agents?

Accepted Answer

A tool-calling agent picks from a fixed set of predefined tools via function calling — structured, controlled, auditable, but limited to what you've provided. A code-generating (CodeAct) agent writes and executes actual code to accomplish tasks — vastly more flexible (it can compose arbitrary logic, loops, data manipulation) but riskier and requires sandboxing.

Tool-calling vs Code-generating:
- Action space — Tool-calling: Predefined tools only. Code-generating: Arbitrary code.
- Flexibility — Tool-calling: Bounded. Code-generating: Very high.
- Safety/audit — Tool-calling: Easier (known tools). Code-generating: Needs sandbox; harder to audit.
- Best for — Tool-calling: Well-defined action sets. Code-generating: Open-ended computation, data tasks.

Research (e.g. CodeAct) shows code-generating agents can be more expressive and efficient — a single code block can chain what would be many tool calls. But they can run anything, so isolation is mandatory (see Q25).

When to choose: "Tool-calling for controlled, permissioned action sets; code-gen for open-ended computation where you can't enumerate every operation — provided you sandbox execution. Many modern agents blend both: predef

Question 16

Explain the ReAct (Reasoning + Acting) agent architecture.

Accepted Answer

ReAct (Yao et al., 2022) interleaves reasoning and acting in a loop: the agent produces a Thought (reasoning about what to do), takes an Action (a tool call), receives an Observation (the result), and repeats until it can answer. It's the foundational agent pattern.

Example:
Thought: I need the user's latest order status.
Action: get_order(user_id=123)
Observation: {status: "shipped", eta: "Jul 10"}
Thought: I have the info; I can answer now.
Action: finish("Your order ships and arrives Jul 10.")

Why it works: pure reasoning hallucinates facts; pure acting has no plan. Interleaving lets reasoning decide what to do and interpret results, while actions ground the agent in real data — sharply reducing hallucination and enabling dynamic multi-step tasks.

Modern note: Production ReAct uses native tool/function-calling rather than parsing free-text "Action:" lines. And every observation from an external tool is untrusted input — the ReAct loop is a prime prompt-injection surface (see Q22).

Reference in assignment: outcomeschool.com/blog/react-agent.

Question 17

What is the Plan-and-Execute agent pattern?

Accepted Answer

Plan-and-Execute separates planning from doing: a Planner first generates a complete multi-step plan for the goal, then an Executor carries out the steps (often delegating to tools/sub-agents), with a re-planning step if reality diverges. It contrasts with ReAct, which decides each step on the fly.

Goal → Planner (full plan) → Executor (step 1 → step 2 → …) → Re-plan if needed → Answer

ReAct vs Plan-and-Execute:
- Planning — ReAct: Step-by-step, reactive. Plan-and-Execute: Upfront, then execute.
- Best for — ReAct: Exploratory, short tasks. Plan-and-Execute: Complex, long-horizon tasks.
- Efficiency — ReAct: More LLM calls (think each step). Plan-and-Execute: Fewer (plan once); cheaper reasoning.
- Weakness — ReAct: Can lose the thread. Plan-and-Execute: Rigid if plan is wrong → needs re-planning.

When to use: "Plan-and-execute shines for structured, multi-step tasks where a stable plan helps and you want fewer expensive reasoning calls. Add a re-plan loop so a wrong initial plan doesn't doom the run."

Reference in assignment: outcomeschool.com/blog/plan-and-execute-agent.

Question 18

What is an agent loop, and how does it decide when to stop?

Accepted Answer

The agent loop is the core cycle — reason → act → observe — repeated until a termination condition is met. Deciding when to stop is a critical design concern: without explicit stop conditions, agents loop forever or quit too early.

Stop conditions (use several):
- Task complete: the model emits a "finish"/final-answer signal.
- Max iterations: a hard cap on steps (safety net against loops).
- Budget/time limit: token, cost, or wall-clock ceiling.
- No progress: detect repeated states/actions and halt.
- Human interrupt or tool-signaled completion.

Design rule: "Always combine a model-decided stop (the agent thinks it's done) with hard external limits (max steps, budget). Relying only on the model to stop is how you get infinite loops (Q31)."

Reference in assignment: outcomeschool.com/blog/ai-agent-loop.

Question 19

What is agent reflection, and how does it improve agent performance?

Accepted Answer

Reflection is a pattern where the agent critiques its own output or actions and iterates to improve — generate a draft, evaluate it against criteria (self-critique or an external evaluator/verifier), then revise. It adds a feedback loop that catches errors the first pass missed (the "Reflexion" idea).

Generate → Reflect/critique ("what's wrong?") → Revise → (repeat until good enough)

Why it helps: a single generation commits to the first attempt; reflection lets the model reconsider, catch mistakes, and self-correct — improving quality on coding, writing, and complex reasoning. Using a separate verifier (tests, a critic model, tool feedback) is stronger than pure self-critique, which can be over-confident.

Trade-off: "Reflection trades extra calls (cost/latency) for quality. Ground it in objective feedback where possible — unit tests, tool errors, a verifier — because a model grading its own work is unreliable. Reserve it for high-value or error-prone tasks."

Reference in assignment: outcomeschool.com/blog/reflection-agent.

Question 20

What is agent orchestration, and how do you implement it?

Accepted Answer

Orchestration is coordinating the components of an agentic system — steps, tools, and (in multi-agent setups) multiple agents — into a coherent workflow: routing, sequencing, parallelizing, managing state, and handling handoffs. It's the "conductor" that decides who does what, when, and with what context.

Common patterns:
- Sequential/chain: steps run in order, output → input.
- Router/dispatcher: a classifier routes each request to the right agent/tool.
- Hierarchical (manager–worker): an orchestrator delegates subtasks to specialized workers/sub-agents.
- Parallel fan-out/gather: run independent subtasks concurrently, then merge.
- Graph-based: nodes + conditional edges with shared state (LangGraph, Q20).

Implementation reality: "Orchestration is mostly state management + control flow + handoff contracts. Frameworks like LangGraph model it as a stateful graph; the hard parts are clean handoff schemas, error recovery between steps, and keeping context scoped so agents don't pollute each other." (Core to Rowboat's cowork orchestration.)

Reference in assignment: outcomeschool.com/blog/ai-orchestration.

AI Engineer interview questions

AI Engineer interview questions

17 topics · 496 questions

Agentic AI

AI Agents

AI Infrastructure and Scalability

AI Safety and Ethics

AI System Design

Behavioral & Scenario Based

Coding and Practical Implementation

Evaluation & Testing

Fine-Tuning & Model Adaptation

Gen AI

LLM Fundamentals

LLMOps & Production AI

Multimodal AI

Must Do

Prompt enginnering

RAG

Vector Databases & Embeddings