Leaving the Chatbot Era Behind

Until recently, most of my AI work has been pretty much turn-by-turn.

Each message kicked off another model call, which might use some files, search the web, write a little script, or use other tools. Then I would look at the result and decide what to ask for next.

Today, I increasingly just describe the outcome I’m looking for and let AI figure it out.

Let me give you an example.

I’ve been using AI to help me with accounting tasks now for years:

A few weeks ago, I was missing a bunch of receipts. Instead of searching manually, I gave my local AI setup (2 NVIDIA DGX Spark) access to roughly 40 GB of Apple Mail exports, plus PDF statements from my banks and credit cards.

I launched OpenCode, intending to explain exactly which receipts were missing. But I was lazy, so I typed something along the lines of:

“Match all available receipts, put them in a list and give me the documents.”

About 90 minutes and zero interventions later, I had the receipts it could find, plus pointers to where I could get the remaining ones.

The shift is from “help me with that” to “do the work for me”.

You can see the same shift in what the big providers are shipping:

Interestingly, all of them seem to have a hard time explaining what these things actually do.

I'll be honest: I find it hard to explain, too.

But here's my best attempt.

In a normal AI chat, every message basically triggers another LLM run. That model can search the web, read files, execute code, call APIs, or use other tools. But the conversation remains the main interaction loop: you send a message, the model does something, gives you a response, and waits for the next message.

And even that line isn’t perfectly clean, because Chat can already use tools and take actions. But the center of gravity is the conversation. Work mode changes that center of gravity by changing where the model operates.

Your message still goes to an LLM, but that LLM is now sitting inside a larger system: a room with files, tools, a shell, context, and potentially other agents. Instead of only using those things to produce the next response, the agent can interact with the room: create files, modify them, run code, fix mistakes, and keep going.

That room might be a folder on your computer, a Git repository, or a hosted environment connected to business systems.

If I had to boil it down, I’d put it like this:

In Chat, the model uses tools primarily to produce the next response. In Work, the model operates inside an environment it can repeatedly interact with and change to achieve an outcome.

The software layer coordinating the model, context, tools, and potentially sub-agents is often called the agent harness.

OpenAI just went one step further and released its Agents API – giving developers managed access to the same harness and infrastructure that powers Codex through an API.

So instead of specifying every step, you can increasingly say: “Here’s the goal. Here are the files. Here are the tools you can use. Figure it out.”

The chat becomes more of a control interface for what happens inside a given environment. You can even assign multiple tasks simultaneously through multiple chat interfaces.

That doesn't make every task suitable for autonomous execution. But it does change what’s worth trying.

There’s an interesting consequence to this: in Chat, I can usually edit an earlier message and simply generate a different conversation from that point. In Work, that’s not necessarily possible. The agent might already have modified files or changed the environment. Reverting the conversation doesn’t automatically revert the work.

That’s why things like checkpoints, permissions, version control, and recoverability suddenly become much more relevant.

When you move from “AI giving you answers” to “AI doing the work for you”, it also changes the way you interact with the AI:

When you chat, you primarily expect something useful back. That might already involve search, files, code, or other tools.

When you work with an agent, you increasingly describe the result you want – and what “done” looks like (ideally unambiguously).

That's why dumb prompting works so well with today's models: strip out the step-by-step instructions, but stay very explicit about the goal.

It works best where the result can be checked. A spreadsheet that reconciles. Code that runs. Numbers that add up.

"Make our marketing better" is still a bad task for an agent.

"Here are last quarter's campaign exports – build me a table of cost per lead by channel and flag anything that doesn't add up" is a great one.

An AI agent can only work with what's in its room.

If the files are a mess, your data is ambiguous, and the tools aren’t available, even the smartest AI will struggle to get some decent results.

Conversely, even “less powerful” models can deliver surprisingly good results when the room and harness are well-designed.

Which is why everything I wrote about data that wants to be chatted with matters even more once your AI stops chatting and starts working.

I used to almost never hit my ChatGPT usage limits. Now, when I work intensively, I run out every couple of days – even on the Business Plan.

The reason for that is that in an agentic workflow, even a very short instruction can now potentially trigger a huge amount of computation behind the scenes. So seat economics increasingly become task economics.

For organizations, it’s no longer enough to ask “How many licenses do we need?” You also need to ask: “How much AI usage is this piece of work worth?”

My rule of thumb is simple: if the usage cost becomes material relative to the value created, it’s probably not a good task for an agent.

Everything above is easiest when you’re using these tools for your own work. I can give an agent access to a folder on my computer, let it change files, watch what happens, and decide whether I trust the result.

Doing the same thing inside an organization is a completely different story.

The moment that “room” touches real business systems, customer data, production databases, or actions with real-world consequences – you need to think about who owns the outcome, how you trace what happened, and how you recover when something goes wrong.

That’s why I still think the technology for AI agents is increasingly ready, while most organizations aren’t.

For your personal work: be more ambitious.

Hand a state-of-the-art agentic system like ChatGPT Work or Claude Cowork a complete piece of work rather than just one step. Give it what it needs to do the job. Define what you want, what “done” means, and where its autonomy ends.

That’s the shift I mean by the end of the chatbot era.

The chat box isn’t disappearing. I use chat-based conversation more than ever. But increasingly, I’m not just exploring ideas or getting my questions answered.

I expect finished work.

See you next Saturday,
Tobias