Agentic AI – the Next S-Curve?
Documenting my thoughts after diving into Agentic AI
Agentic AI is the next step in the evolution of Generative AI—and it has already begun. It all starts with the LLM (large language model) — not just a model that understands a prompt and produces a smart answer, but one that can plan, orchestrate, and call tools, in order to achieve a goal. In other words, it is more than a mere langauge interview between humans and computers and can actually make reasoned decisions allowing it to act like an operator that can research, call APIs, run code, update a ticket, query a system, and return with results.
The LLM has become a practical point of execution. The model becomes a “brain” coordinating a set of tools (eg web browsing, databases, internal docs, SaaS apps, and code execution). The LLM isn’t replacing those systems (yet) – it is the layer that decides what to do next, translates intent into actions, and stitches outputs into a coherent outcome.
How is Agentic AI possible if an LLM is just probabilistic next-token prediction? It is because learning to predict language at scale forces the model to internalize patterns of human reasoning, procedures, and decision-making that are embedded in text. When prompted, the model can generate plans, choose next steps, and produce structured outputs (ex tool calls) that an external system can execute. Wrapped in a control loop (eg plan > act with tools > observe results > iterate), the LLM becomes a practical coordinator for multi-step tasks. It isn’t inherently “wise” or guaranteed to be correct, but it’s often good enough at producing useful plans and next actions, especially when combined with tools and verification.
The near-term impact is straightforward: productivity. Agentic AI begins as a high-leverage assistant that makes humans faster (drafting, research, operational automation), then steadily becomes more autonomous—handling multi-step workflows with less supervision. Over time, that shifts the human role from “doer” to manager of a small team of agents: setting objectives, defining constraints, and approving outcomes.
In this article, I’m going to outline a few use cases that seem ripe for Agentic AI, and discuss key strategic patterns and how they are implemented, in order to get a deeper sense of how this will all work. I’m documenting all of this as part of my own learning journey but also to share my knowledge with anyone who is interested.
Use Cases
Agentic AI is going to work best when ambiguity is low, the process is well-defined, and success can be measured with clear signals (eg. did it resolve the ticket? did it return the right record? did it pass the test suite?). That sweet spot includes a ton of valuable work: repetitive workflows, operational “glue” tasks, and decisioning that’s bounded by policy and data. I anticipate greater ambiguity will be handled well in time, but the adoption math will start with low ambiguity and work its way into greater more ambiguous problems as capabilities improve. In the near term however, here are a few key use cases that seem highly addressable, to demonstrate how this will work:
Ex1: Customer Support – Agents can classify issues, retrieve the right policy/docs, propose a response, and even take constrained actions (refund requests, account updates) with HITL approvals for sensitive steps. The big win is handling the long tail of repeatable tickets while escalating edge cases to humans with better context.
Ex2: Sales Prospecting – Agents can build target lists, enrich leads, draft outreach sequences, and personalize messaging based on public data and CRM history. In practice, the highest ROI tends to be “sales ops automation” (research + list building + first-draft messaging) rather than fully autonomous selling.
Ex3: Data Analytics – Agents can pull data, generate SQL, run analyses, draft dashboards, and explain results in plain language — then iterate when stakeholders ask follow-up questions. This is especially powerful when the system has reliable retrieval and governance (semantic layers, metric definitions, data permissions).
Ex 4: Inventory Management – Agents can monitor inventory signals, forecast stock risk, recommend replenishment actions, and automate routine adjustments within policy bounds. The trick is integrating tightly with operational systems and making sure decisions are explainable and auditable.
Strategy Patterns
There are a few foundational patterns that industry leaders are converging on that provides guidance around the the sort of generalized problems that Agentic AI may be well equipped to address. Here are the four patterns identified by Andrew Ng, the AIML thought leader who also popularized the term “Agentic AI”:
Pattern #1: Reflection – Instead of taking the first output, the system prompts the model to critique, improve, and validate its own work. This is a cheap way to increase quality: generate > review > revise, often with explicit rubrics (tone, completeness, correctness).
Pattern #2: Planning – The agent decomposes a goal into steps, decides an execution order, and tracks progress. Planning is especially useful when tasks require multiple tool calls and intermediate checkpoints (eg “research > synthesize > draft > verify > format”).
Pattern #3: Tool Usage – The model learns when to stop guessing and call tools: search, database queries, calculators, code execution, internal APIs. This is the core “agentic” capability: the model isn’t the whole solution; it’s the coordinator that knows when to fetch, when to compute, and when to act.
Pattern #4: Multi-Agent – Instead of one generalist, you use multiple specialized agents (researcher, writer, verifier, executor) that coordinate and hand off work. This pattern can boost robustness, but it also increases orchestration complexity — so it shines most on larger workflows where specialization pays off.
Implementation Patterns
Under the hood, agentic behavior is usually implemented as a loop (eg observe > think > act > observe again) with guardrails, memory, and tool integrations layered in. The patterns below are common building blocks, and you can mix them together depending on what you’re building.
Impl #1: ReAct – ReAct combines reasoning with actions, so the model can gather information from tools/environments mid-task and adjust its plan. This often outperforms “reason-only” approaches because the agent can correct itself as it learns new facts. Think about how LLMs already search for information online when you ask a question. That’s taking an action but that action could be anything.
Impl #2: CodeAct – This is a specialized coding version of ReAct. With CodeAct, the agent treats code execution as the primary action interface. The model writes code, runs it, inspects outputs/errors, and iterates. This is particularly effective for analytics, automation, and repeatable workflows where code is the cleanest glue.
Impl #3: Agentic RAG (Vector) – Traditional RAG is often a linear pipeline: retrieve context, then generate an enriched prompt that will be passed to the LLM. Agentic RAG adds decision-making to the equation. The agent can decide whether retrieval is needed, which sources to query, and when to retry retrieval with a refined query — frequently using a vector database as the retrieval layer.
Impl #4: Routing (MCP, A2A) – Routing is the pattern of classifying intent and sending work to the right downstream tool/agent/workflow (eg FAQ vs RAG vs human escalation). As protocols standardize tool connectivity, routing becomes less “hard-coded wiring” and more “policy + configuration.”
Impl #5: Human in the Loop (HITL) – HITL is the safety valve. The agent runs autonomously for low-risk steps, but requests human approval for sensitive actions (payments, access changes, external comms) or when confidence is low. In production systems, HITL is often designed as an explicit workflow state (approve / reject / edit / escalate), not a vague expectation.
Agentic System Components
Okay, but what do you need to consider when actually building one of these systems? The LLM is core to Agentic AI but in its current state, it is not the whole story. Here are a few key components that will also be needed to build a complete Agentic system:
Memory – Memory is how an agent maintains continuity across steps and sessions (what we already tried, user preferences, decisions made). It can be short-term (within a run) or long-term (persisted profiles, project state). This is often implemented using a Vector DB (ex Pinecone) that is optimized for use with an LLM.
Retrieval – Retrieval is how the agent “grounds” itself in external truth: internal docs, tickets, CRM records, policies, code, etc. Done well, retrieval turns “clever guessing” into “evidence-backed execution.” This is foundationally what RAG is all about – infusing the process with contextual knowledge and seeking citations that offset hallucination risk. This is particularly critical for internal systems, to provide contextual knowledge.
Prompt Engineering – Prompting is still the control surface: role instructions, rubrics, tool policies, formatting constraints, and “what good looks like.” In agentic systems, prompts become less about clever phrasing and more about operational discipline (clear steps, clear stop conditions, clear escalation paths). Much of that prompt engineering can be programmatic however and assembled during the RAG process, looking up key information and enriching the prompt, using templates, etc.
Actions & Orchestration – Actions are the tools the agent can call; orchestration is the logic that decides when to call them, in what order, and what to do with results. This is where loops (ReAct), planners, routers, and multi-agent handoffs live. Think about all of the 3rd party SaaS systems and utilities that are available online and are introducing MCP layers to enable interaction with LLM systems. Each of these is a potential action that could be taken.
Governance & Evals – Governance means permissions, audit logs, rate limits, and safety constraints; evals are how you measure whether the agent is improving (task success rate, correctness, refusal quality, regression tests). Agentic AI becomes trustworthy at scale only when it’s measurable and controllable. This is going to become a very important part of Agentic AI as companies seek to deploy them at scale, and run into trust and fairness issues along the way. There are real world implications that must be considered in order for these systems to be deployed successfully.
Future of Agentic AI
The near future of Agentic AI will be defined less by “the perfect agent” and more by early pioneers and serve as industry “proofs of concept” and an ecosystem that forms around enabling frameworks and capabilities, as well as standards to improve reliability and adoption. A growing share of “agentic capability” will get commoditized and bundled into mainstream products, so teams won’t always need to custom-build agents from scratch – we can already see the beginnings of this, with platforms like ChatGPT providing multi-modal capabilities, native integration of 3rd party tools, and connectors to import Slack, email, and Google docs for context.
At the same time, protocols and standards will create an integration fabric that makes it dramatically easier for agents to connect to tools, data sources, and even other agents across vendors. As interoperability improves, the default approach will inevitably shift from bespoke integration, to plugging into an existing ecosystem and composing larger, end-to-end flows with far less effort. This plumbing will also make simple, personal agents far more viable and accessible. And while it’s tempting to imagine agents that “rewrite themselves,” the more realistic (and more useful) path is continuous improvement through feedback loops: capturing failures, running evals, refining prompts and tool policies, improving retrieval, and iterating on workflows.
Systems will become better over time, at proposing fixes and testing them safely, but will find a harmonious balance between self-improvement and human-driven evaluation and guardrails.. As models and architectures improve, we should also see stronger planning and decisioning, which will reduce the need for Humans-in-the-Loop (HITL) on routine work for many tasks. In reality, there are some high-risk/impact decisions that likely will always require some degree of human insight (eg legal, medical decisions) – this balance will be more driven by our social contract with technology however, rather than a result of technical inability.
Conclusion
The Generative AI wave has only recently arrived and already has profound implications, but the next S-curve is forming quickly. Agentic AI moves beyond content generation into execution (eg planning work, calling tools, and completing tasks). The upside is a major leap in productivity, but the challenge is building the right balance of autonomy and accountability.
It’s still early, and today’s systems are imperfect, which is why most deployments will need to keep humans in the loop. But as agentic workflows mature into more autonomous agents, and standards reduce the friction of integration, the direction is clear: humans will shift from “operators” to managers of AI coworkers, setting objectives and constraints while teams of agents handle more of the day-to-day execution. The smartest path forward is to start with bounded workflows, measure outcomes, and expand autonomy as reliability proves itself.