8 Levels of AI Adoption: From Chat to Autonomous Agents
The following is an AI generated summary of the video
The AI Capability Ladder: From Chatbots to Digital Workers
A year ago, I described AI in fairly simple terms. At the time, I was experimenting with Retrieval-Augmented Generation (RAG) using Mistral running locally via Ollama, with my own data attached to a language model.
Since then, both my understanding and the technology have moved on considerably.
Rather than thinking about AI as a collection of unrelated tools, I now think of it as a capability ladder. Each rung adds a new capability, gradually moving from manual interaction towards systems that own business responsibilities.
The model isn't perfect—there's overlap between layers—but I've found it to be a useful way of thinking about the space.
Level 1: Chat
This is the foundation.
Examples include:
- ChatGPT
- Claude
- Gemini
- GitHub Copilot
These systems are incredibly flexible. You can ask almost anything, but every interaction is manual. If you regularly need the AI to produce work in a particular format or style, you're repeatedly providing the same instructions.
The capability is simple:
General conversation.
The drawback is equally simple:
You have to tell it what to do every time.
Level 2: Prompt Templates
The next step is saving those repeated instructions.
Whether you call them prompt templates, projects, or custom prompts, the idea is the same:
- consistent tone
- consistent structure
- consistent process
For example, I regularly convert YouTube transcripts into blog posts.
I have a saved prompt which tells ChatGPT:
- how to structure the article
- to output Markdown
- to match my writing style
Now I simply paste in a transcript and receive a ready-to-publish Markdown article.
That saves time without changing the underlying workflow.
The limitation is that the AI still doesn't know anything about my business unless I provide the information each time.
Level 3: Knowledge Assistants
The next capability is knowledge.
Rather than simply remembering instructions, the AI also has access to domain-specific information.
Examples include:
- Custom GPTs
- RAG assistants
- Company knowledge bots
For example, I have a GPT loaded with the content from my website.
I can ask questions like:
Has Gavin done any research into LLMs?
or
What technologies has Gavin written about?
The answers come from my own published material rather than the model's general knowledge.
Last year I built exactly this using:
- Mistral
- Ollama
- FAISS
- a local vector database
- a small Python frontend
The principle is the same regardless of the tooling.
The limitation is that someone still has to ask the question.
Level 4: Automation
The next step removes some of the human interaction.
Instead of waiting for someone to ask, the system performs predefined tasks automatically.
For example:
Every Friday, summarise completed Asana tickets and post the results into Slack.
This is straightforward to build using modern automation platforms.
The important distinction is that the workflow is still explicitly defined.
The automation isn't making decisions.
It's simply following instructions.
Level 5: AI Agents
This is where reasoning starts becoming important.
An AI agent isn't just executing a workflow.
It's given a goal and decides how to achieve it.
For example, instead of asking:
What changed this week?
you might ask:
What changed that actually matters?
The agent might:
- inspect ticket priorities
- use company knowledge
- examine related systems
- decide what deserves attention
This feels much closer to declarative programming.
Instead of specifying every individual step, you're specifying the desired outcome.
The limitation is that the agent still performs a single job before stopping.
It doesn't own an ongoing responsibility.
Level 6: Autonomous Agents
An autonomous agent continuously works towards a responsibility.
For example:
An ordinary agent might:
Research our competitors and write a report.
An autonomous agent might instead:
Continuously monitor competitors and notify me when something important changes.
Another example would be maintaining a technology radar.
Rather than periodically researching frameworks manually, the agent continually watches the ecosystem, evaluates new developments and highlights anything relevant.
Instead of completing jobs, it's fulfilling a role.
Level 7: Multi-Agent Systems
Sometimes a single agent isn't enough.
A multi-agent system consists of specialist agents collaborating towards a shared objective.
Typically, there is:
- a coordinator
- several specialist agents
- shared memory
- shared state
- communication between agents
Rather than one AI attempting everything, different agents specialise in planning, research, coding, evaluation or communication.
Together they become more capable than a single model working alone.
Level 8: Digital Workers
The final step is what many people mean by a digital worker.
At this point the AI isn't completing individual tasks.
It owns an entire business responsibility.
Examples might include:
- customer service
- software engineering
- business analysis
- operations support
Humans no longer direct every action.
Instead, they manage the AI in much the same way they would manage a member of staff.
That's a fundamentally different relationship.
The AI is responsible for achieving outcomes rather than simply executing instructions.
Where Does Agentic Coding Fit?
Tools like:
- Codex
- Claude Code
- OpenHands
- Antigravity
don't really form a separate rung.
They're applications of the higher levels of the ladder—roughly Levels 5 through 8.
You describe what you want.
The system plans.
It edits code.
Runs tests.
Fixes problems.
Repeats.
Personally, I use Codex extensively, with Antigravity as a backup when I run out of credits.
The productivity gains are significant.
One of my children recently designed a bullet-hell shooter inspired by our late hamster. Using these tools, the project came together remarkably quickly.
Why Think About AI This Way?
The model isn't perfect.
There are overlaps.
Automation doesn't necessarily require knowledge.
Knowledge assistants don't always require prompt templates.
Agentic coding cuts across several layers.
But I still find the ladder useful because it answers a simple question:
What additional capability are you getting by adding more complexity?
Each step moves a little further away from manually directing software and a little closer to delegating responsibility.
The progression looks something like this:
| Level | Capability Added |
|---------------------|---------------------------------|
| Chat | Conversation |
| Prompt Template | Consistency |
| Knowledge Assistant | Domain knowledge |
| Automation | Scheduled execution |
| AI Agent | Reasoning towards goals |
| Autonomous Agent | Ongoing responsibility |
| Multi-Agent System | Collaborative autonomy |
| Digital Worker | Ownership of business functions |Viewed this way, AI isn't a collection of disconnected products.
It's a gradual shift from imperative interaction—telling the system exactly what to do—to declarative interaction, where you define the outcome and let increasingly capable systems determine how to achieve it.