The first time I watched an agent run end to end, the surprising part was not that it answered a question. It was that it didn't stop. It read a file, decided the data was incomplete, went and fetched what it was missing, ran a check, found the check failing, and tried a different approach. Nobody clicked anything between those steps. That gap, between answering and acting, is the whole idea behind agentic AI.
Most software you have ever used is passive. You click a button and it runs a task. You type a query and it returns an answer. The machine is powerful but it waits. An agentic system is built to not wait. It observes its situation, reasons about what needs doing, and takes initiative. That shift sounds small written down. In practice it changes what you can hand to a computer.
What agentic AI actually means
The word comes from agency: the capacity to act and make choices. An agentic AI system is one that can chase a goal across many steps, decide what to do at each one, reach for external tools such as a browser, a code runtime, or an API, and change its plan based on what it learns along the way.
Compare that to a plain language model. A model takes an input and gives you an output. One turn, one response, done. An agent uses a model as its brain, but wraps it in something that can run for minutes or hours: searching, writing and running code, moving files, sending messages, and catching its own mistakes until the task is finished. The model is the engine. The agent is the car.
The four things every real agent does
There is a lot of hype around the word "agent," and plenty of tools claim it without earning it. The honest test is whether a system does these four things. A glorified autocomplete does one of them. A real agent does all four.
Perception
It takes in information from more than one place: text, images, a database, an API response, a calendar, a web page. From that, it builds a working picture of where it stands right now.
Reasoning and planning
Given a goal, it breaks it into smaller tasks, sees obstacles coming, and chooses between approaches. This is where the language model does its heavy lifting.
Action
It does things in the world: runs code, queries a database, opens a URL, calls an API, writes a file, hands work to another agent. It is not advising you. It is acting.
Memory and feedback
It holds context across steps, rewrites its plan when results surprise it, and learns inside the session. Some agents keep what they learn across sessions too.
How an agent actually works
Strip away the magic and an agent is mostly engineering. At the centre of almost every system today is a loop that keeps running until the task is done or the agent decides it is stuck. If you have read our piece on agentic AI versus RPA, this loop is the line that separates the two: a script repeats fixed steps, an agent decides the next step each time around.
The loop: think, act, observe, repeat
The common pattern is called ReAct, short for reasoning and acting, and most modern designs are a version of it. It goes like this.
Think
The agent gets a goal and reasons through it in the open: what is the problem, what does it need, what is the next move. This thinking is visible, which matters later when you want to know why it did something.
Act
It calls a tool. Maybe it searches for current data, reads a file, runs a Python script, or queries a database. Each call is one discrete, auditable step rather than a black box.
Observe
The tool returns something: a page of text, a script's output, a row from a database. The agent reads that result and folds it into what it already knows.
Repeat
It reflects on what changed, updates the plan if needed, and either calls another tool or stops with an answer. For a hard task this loop can run hundreds of times before it finishes.
A note from the build side. The frameworks people reach for here are LangGraph, AutoGen, CrewAI, and the tool-use APIs from the model labs. They let an engineer define what an agent is allowed to do, what tools it can touch, where its memory lives, and how several agents talk to each other. None of that is the hard part. The hard part is deciding when the agent should stop and ask a human, and what a wrong answer costs if it doesn't.
When one agent isn't enough
Some problems are too big or too varied for a single agent to handle cleanly. Multi-agent setups split the work across specialists: a planner, a researcher, a coder, a reviewer, each with a narrow job, coordinating through structured messages. It ends up looking like a small project team that runs itself, which is roughly the point.
The kinds of agents you'll meet
Not every agent is the same animal. In practice people sort them by how wide their remit is and how much they are trusted to act without a person watching.
Task-specific agents
These are built for one narrow job: a support agent that handles refunds, a coding assistant that writes and tests functions, an invoice agent that reads a bill, matches it to a purchase order, and flags the ones that don't add up. They are reliable inside their lane and useless outside it, which is usually a feature, not a bug.
General-purpose agents
These work across a much wider range with a broad set of tools. One agent might research a topic, draft a report, book a meeting, and update a spreadsheet from a single instruction. The computer-use agents from the major model labs sit in this camp. They are impressive and still rough at the edges.
Reliability or reach
The choice between the two comes down to one axis. Task-specific agents trade breadth for reliability. General-purpose agents trade reliability for breadth. Neither is better than the other; they are tuned for different jobs.
Where most teams start
For real work inside a company, almost everyone starts narrow and widens out once the narrow thing is boringly dependable. If you want a gut check on whether your team is at that point, we wrote about the signs a team is ready for agents.
Fully autonomous vs. human-in-the-loop
Some agents run with no approval at any step. Others pause at checkpoints and wait for a person before anything high-stakes: sending an email, moving money, deleting a file. Most systems running in production today are the second kind, and that is the right instinct. The edge cases are where agents go wrong, and a wrong action is harder to undo than a wrong sentence. The same logic is why agentic document extraction escalates the documents it can't justify instead of guessing.
These describe how agents are built, not market forecasts. We have left the billion-dollar projections to the analysts who like making them.