Netflix's latest AI documentary, “The AI Doc", kicks off by lobbing the world's simplest question at a bunch of AI boffins: "What is AI?" You'd think this lot would have it down pat...but no. Cue much head-scratching and a flurry of answers, none of which seem to agree.
Here's what I want you to do:
Stop reading. Close your phone/laptop browser/email client. Open a notes app (or a notepad) and try to answer that question: What is AI? Try to define AI.
It's a fun exercise, mostly because you'll learn a thing or two about how we can know a concept intimately but still struggle to define it explicitly.
Here's what I managed after five minutes of existential flailing.
Artificial Intelligence is a branch of computer science that is concerned with building systems that can perform tasks typically associated with human intelligence, like learning, reasoning, language processing, and judgment.
Is that accurate? Maybe. Complete? Ask five experts and get six opinions. I'm not pretending it's the gold standard.
The point is, you can know something inside out and still sound like you're making it up when asked to define it.
Let's look at another term being talked about everywhere: AI Agents.
Again, if you are so inclined, stop reading here and try to define it yourself. What do you mean by "AI Agent" in the context of Generative AI and language models?
Sounds simple enough!?! At least, I thought defining an AI agent would be fairly straightforward. Then I started reading, and somehow ended up needing a definition of an agent harness too.
A long time ago…
In Artificial Intelligence: A Modern Approach, Russell and Norvig put it simply: “An agent is just something that perceives and acts.”
An "agent" is something that receives information from its environment and does something in response. Learning and elaborate reasoning aren't prerequisites. We haven't even got to whether it makes good decisions yet.
Over in Reinforcement Learning camp, Kaelbling, Littman and Moore's 1996 survey describes RL as:
“the problem faced by an agent that learns behavior through trial-and-error interactions with a dynamic environment.”
Here, the interest is in how the agent learns which actions pay off over time.
These ideas overlap rather than represent successive upgrades. One describes a system that perceives and acts; the other concerns learning how to act.
What do the people building LLM agents mean?
Let's look at a few perspectives.
Anthropic describes agents as: “systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.”
They make a point of separating these from workflows, where everything plods along a set path (" systems where LLMs and tools are orchestrated through predefined code paths"). Interestingly, both get lumped under the title of 'agentic systems'. You can be agentic without actually being an agent 🤷. Try not to think about it too hard.
OpenAI starts with:
“Agents are systems that independently accomplish tasks on your behalf.”
Their guide expects the LLM to actually run the show and pick its own tools, so no, you can't just slap 'agent' on every bit of automation and call it a day.
LangChain gives us:
“An AI agent is a system that uses a large language model to decide the control flow of an application.”
It feels like they're all singing from roughly the same hymn sheet, just with different solos. OpenAI cares about what gets handed off; Anthropic and LangChain are fussed about who's calling the shots. Compared to the old-school definition, these lot are obsessed with the model picking its next move.
And just when you think it's safe, along comes the harness…
Until this point, most definitions focus on the agent itself. But The Anatomy of an Agent Harness adds another layer: Agent = Model + Harness
In that article, the harness is basically everything except the model itself: prompts, tools, state, orchestration, execution logic, and whatever constraints you fancy. They even throw in filesystems and sandboxes for good measure.
That at least gave me a line in the sand: the agent is the whole shebang, model and harness included. The harness manages what the model sees, executes its tool requests, and keeps the loop running.
Take a hypothetical coding agent. The model requests a test run. The harness dispatches the request to the test tool, captures the result, and supplies it to the model. The model can then decide whether to inspect another file or attempt a fix. Approval checks and execution limits can be enforced around those steps.
The harness equally shapes the decisions themselves: what context the model receives, which tools it sees, and when it must stop for approval. It isn't just passing messages around.
This clears up why I've been confused. When I say 'I'm building an agent', most of what I'm actually doing is wrangling harness code. I mean the whole contraption, even if I'm just bolting bits onto someone else's model.
Naturally, even a harness doesn't have a universally fixed boundary. In Anthropic's Managed Agents architecture, the harness is the model-calling and tool-routing loop, with the session history and sandbox treated as separate components. LangChain's article uses a larger boundary.
So… how agentic are we talking?
Splitting things up helps a bit, but it doesn't tell you how much the system is actually thinking for itself. LangChain says it's a spectrum, depending on how much of the reins you hand over to the model.
For a coding task, I picture it like this:
- Prescriptive workflow: 'Read this file, propose a patch, run this test, and bring me the result.' I'm still the one calling the shots.
- Bounded autonomy: "Investigate the failure and choose your approach, but ask me before making changes."
- Fully autonomous execution of a defined task: "Fix the failure, test your changes, and keep working until you're finished." I have delegated the process as well as the individual steps.
Of course, that doesn't mean I'm letting it loose on production. You can give it free rein on the task and still keep it on a short leash.
And honestly, aiming for full-blown autonomy isn't always the dream. Anthropic sensibly suggests using the simplest thing that gets the job done, even if that's just a glorified checklist.
I started this exercise looking for a definition. I've ended up more interested in what we're actually delegating.
Calling something an agent tells me less than knowing what it's allowed to decide, what it can actually do, and when it has to come running back for help. The harness is where all those rules get nailed down in code.
So, after all that, what’s my definition of an AI agent?
For the LLM-based systems I’ve been talking about, here’s where I’ve landed: An AI agent is a system built around an LLM that can choose and carry out actions towards a goal, using tools, context and feedback to decide what to do next.
In practice, that means giving it tools to act, some memory of what’s happened, and room to plan its next steps. That memory might simply be the history of the current task, rather than anything it remembers between sessions. The harness manages the context, executes tool requests, and feeds back the results so the model can adjust its approach.
That’s what I mean when I say I’m building an agent: giving a model some responsibility for figuring out how the work gets done, along with the machinery to verify the work until the task is done.
No spam, no sharing to third party. Only you and me.