How people should talk to AI agents

The idea

Talking to an agent should feel like messaging a friend, family member or colleague to get something done.

You do not decide which conversation to have it in. You do not wipe their memory when the topic changes. You do not think about how much they can hold in their head. You just message them and the thing gets done.

That is the whole theory. Most AI products, including ours until now, do not work like that.

What is actually wrong

I have been using agents every day for months. Not demos, real work.

The thing that wears you down is not the quality of the output. It is everything around it.

You start a new session because the old one got long. You clear the context because the agent keeps dragging in something from two hours ago that has nothing to do with what you are asking now. You keep a mental list of which chat had the useful thread in it. You copy things between chats. You start over and explain yourself again.

None of that is the work. That is the user doing the tool's job for it.

And it is not a small problem. There is a name for it now. It got coined on Hacker News last year and it stuck:

Maybe you can call it context rot, where as context grows and especially if it grows with lots of distractions and dead ends, the output quality falls off rapidly.

Simon Willison picked it as one of his words of the year for 2025. Chroma ran the research on it across 18 models and found the same thing: as input grows, performance gets less reliable.

So the model gets worse as the chat gets longer. Every product built on top of these models knows this. The question is who has to deal with it.

Right now the answer is the user. That is wrong.

Context engineering is our job, not yours

Look at how the people building this stuff describe the problem.

Andrej Karpathy, on why context engineering is a better term than prompt engineering:

When in every industrial-strength LLM app, context engineering is the delicate art and science of filling the context window with just the right information for the next step. Science because doing this right involves task descriptions and explanations, few shot examples, RAG, related (possibly multimodal) data, tools, state and history, compacting [...] Doing this well is highly non-trivial.

Tobi Lutke, the CEO of Shopify, in the post Karpathy was replying to:

I really like the term "context engineering" over prompt engineering. It describes the core skill better: the art of providing all the context for the task to be plausibly solvable by the LLM.

Read those again. Delicate art and science. Highly non-trivial. The core skill.

Then ask why a sales manager who wants a report is expected to do it manually, by opening and closing chat windows.

Anthropic's engineering team, writing about how they build agents on Claude, puts it in terms of a budget:

Context, therefore, must be treated as a finite resource with diminishing marginal returns. Like humans, who have limited working memory capacity, LLMs have an "attention budget" that they draw on when parsing large volumes of context.

The context window is the agent's working memory and it has a budget. Deciding what goes into it at each step is a real engineering problem. It is our job. We should not be handing it to the customer and calling it a feature.

The rule we are building to

Jakob Nielsen, who has been writing about interface design since before most software had a graphical one, called generative AI the first new UI paradigm in 60 years:

With the new AI systems, the user no longer tells the computer what to do. Rather, the user tells the computer what outcome they want.

Session management breaks that. Clearing a context window is not an outcome anybody wants. It is an operation, and it is the old paradigm sneaking back in through the side door.

So the rule is simple.

One agent, one chat. Forever.

Not one chat per task. Not one chat per project with folders and archives. One relationship, the same way you have one thread with each person you work with. You come back tomorrow and carry on, because that is what everyone already expects from every messaging app they have used for the last fifteen years.

Three things follow from that:

• No session management. Nothing to start, clear, name or organise. If "new session" is the main button in the interface, the design has already failed.
• No context management. What to keep, what to summarise, what to drop, when to pull something back in. All of that happens on our side and the user never sees it.
• No mode switching. You should not have to know whether you are chatting, configuring or executing. It is one conversation that can also do things.

The test is simple. If someone has to understand how the agent works in order to use it, we have pushed our problem onto them.

Why this matters more for companies

A power user will put up with session juggling. Some of them even like the control.

A company will not. If getting value out of an agent means understanding context windows, then the tool only works for the two people on staff who find AI interesting. Everyone else quietly stops opening it and the pilot dies.

Adoption inside a company depends on the thing being obvious to someone who has no interest in AI as a subject. The bar is not "an engineer can drive this". The bar is "anyone who uses WhatsApp can drive this".

One chat clears that. A workspace full of sessions, threads and context controls does not.

Workflows follow the same rule

The obvious objection is that some work is too structured for a chat. Multi step processes, scheduled runs, approvals, branches.

The structure should exist. But building it should not turn into a second product with its own canvas, its own vocabulary and its own learning curve.

You describe what should happen, in the same chat, in plain language. The agent builds the workflow and shows it back to you. If it is wrong you say what is wrong. The agent should also be smart enough to notice when you keep asking for the same thing and offer to make it repeatable.

Chat is the interface. The workflow is something the agent produces and runs for you, not an app you have to learn.

What we are changing

Basepoint Work is being simplified around this. One continuous chat per agent. Context handled automatically. Workflows built by talking, not by wiring boxes together.

Less to look at, in other words. The hard part moves behind the chat window, where it belongs.

What we care about is whether someone can be useful with an agent in the first minute, without reading anything first. Every control we take out of the interface is a bet that we can do that job better than the user can do it by hand.

I think that is the right bet.