Home/ CSE/ Agentic AI and Autonomous Workflows
CSE · Seminar 01 · LLM agents that plan, act and self-correct

Agentic AI and Autonomous Workflows

Agentic AI moves beyond single-shot chat completion to systems that decompose goals, call tools, observe results and iterate until a task is genuinely complete.

LLM agentsReActtool useorchestration2026

An agentic system wraps a large language model (LLM) inside a control loop that lets it reason, take actions in the external world through tools, observe the outcome, and decide the next step. Unlike a one-turn assistant, an agent maintains a working memory of its trajectory and pursues a goal across many steps — booking travel, refactoring a codebase, or running a multi-stage data analysis without a human in the loop for every action.

Working principle

Most production agents implement a variant of the ReAct pattern (Reason + Act). The model emits an interleaved stream of thoughts and actions; each action is a structured tool call whose result (the observation) is fed back into the context window for the next reasoning step. A planner may first break the goal into sub-tasks, while a critic or verifier checks intermediate output and triggers self-correction when a step fails.

1Perceive goal & state2Plan / decompose3Select tool4Act (call tool)5Observe result6Reflect & correctCONTINUOUSCYCLEReAct-style agent loop with reflection
Figure 1. The core sense–plan–act–reflect loop. The agent re-enters the loop until a termination condition (goal satisfied, budget exhausted, or human approval) is met.

Architecture of an autonomous workflow

Real deployments separate concerns into layers: an orchestrator that manages the loop and state, a tool / function-calling layer that exposes APIs, databases and code execution, a memory subsystem (short-term scratchpad plus long-term vector store), and guardrails that constrain what the agent may do.

Goal & policy layerUser intent, constraints, success criteriaL5OrchestratorPlans, routes, manages multi-step state machineL4Reasoning model (LLM)Generates thoughts, plans and tool callsL3Tool / action layerAPIs, code exec, search, databases, other agentsL2Memory & guardrailsVector memory, validation, human-in-the-loop checkpointsL1Layered reference architecture for an autonomous workflow
Figure 2. Reference stack. Multi-agent systems replicate this stack per agent and add a coordination protocol between them.
Table 1. Single-shot assistant vs. agentic workflow
PropertyChat completionAgentic workflow
HorizonOne turnMany steps until goal met
External actionsNoneTool calls, code, API writes
StateStateless / context onlyPersistent memory + scratchpad
Failure handlingUser retriesSelf-reflection & retry
Main riskHallucinationCompounding errors, unsafe actions

Applications

  • Autonomous software engineering — issue triage, code generation, test-and-fix loops
  • Operations copilots that resolve tickets by querying systems and executing fixes
  • Research and data-analysis agents that gather, clean and synthesise sources
  • Customer-workflow automation: claims, onboarding, procurement

Challenges

Key insightThe dominant failure mode is error compounding: a small mistake early in a long trajectory cascades. Robust agents therefore add verification at every step, cap tool budgets, and keep a human approval gate on irreversible actions.
  • Reliability over long horizons and cost of repeated LLM calls
  • Tool-use safety and prompt-injection from retrieved content
  • Evaluation — measuring task success, not just token-level accuracy

References & further reading

  1. Yao et al., “ReAct: Synergizing Reasoning and Acting in Language Models,” ICLR 2023.
  2. Shinn et al., “Reflexion: Language Agents with Verbal Reinforcement Learning,” NeurIPS 2023.
  3. Wang et al., “A Survey on Large Language Model Based Autonomous Agents,” 2024.
‹ Back
All CSE topics