Why long horizon is AI's next hard problem

- “Based on your current understanding, what’s one key, important bet?”

- “Long horizon.”

I first noticed the term long horizon in that four-hour-plus interview with Shunyu Yao, which was excellent.

At first I thought it was about “long-term memory.”

Later I realized it isn’t.

Long horizon isn’t simply saying AI should remember for longer.

It’s more like asking:

can AI keep hold of its goal, state and actions across a very long task?

That’s much harder than “answering a question.”

Because to answer a question, AI only has to be smart within the current context.

But to complete a long task, AI has to know:

• how far it’s gotten;
• which judgments have changed;
• which information is only an old assumption;
• which mistakes must not be repeated;
• what to do next;
• how to check the result once it’s done;
• how to carry on after being corrected midway, instead of starting from scratch.

That’s what’s really hard about long horizon.

It isn’t one beautiful answer.

It’s whether AI can avoid getting lost over time.

What exactly is long horizon?

Put very simply:

long horizon = the ability to handle tasks that span a long stretch.

The “horizon” here can be understood as the task’s field of view, or its span.

Short-horizon tasks are things like:

• translate this sentence for me.
• summarize this article for me.
• explain a concept for me.
• edit this piece of copy for me.

These usually need just one input and one output.

You give AI the material, it reads it, and it answers you.

But long-horizon tasks are things like:

• help me build a product.
• help me find a job.
• help me write a series.
• help me finish a coding project.
• help me research a complex question.
• help me keep improving a workflow.

These aren’t done in one go.

They span many steps. New information keeps appearing. Old judgments need revisiting. Direction changes midway. There are mistakes, feedback, corrections, and more execution.

So long horizon isn’t just “a bit more memory.”

It’s closer to:

long-term goal + multi-step plan + context management + memory + tool use + state updates + error recovery + verifying results

Only all of this together counts as the ability to handle long tasks.

How is long horizon different from long-term memory?

This is easy to confuse.

Long-term memory is:

• AI remembering what you said before.
• Remembering your preferences.
• Remembering the project background.
• Remembering past decisions.

But long horizon is:

• whether AI can keep acting, based on those memories, along a very long chain of work.

So long-term memory is only part of long horizon.

An analogy.

You ask someone to help with a project.

A good memory certainly helps. But remembering a lot doesn’t mean they can get things done.

They also need to be able to judge:

• what the goal is now;
• which earlier plan has already been overturned;
• what the latest feedback means;
• what to do next;
• when to keep going;
• when to stop and reassess.

Otherwise, they’re just a chaotic colleague with a great memory.

AI is the same.

Memory solves:

where past information is.

Long horizon solves:

how that past information should be used today.

They aren’t the same thing.

Why is everyone paying more and more attention to long horizon now?

Because AI is already very good at “answering.”

• Ask it an isolated question and it often answers well.
• Give it a passage and it can summarize it.
• Give it a concept and it can explain it.
• Ask it to write some code and it can do that too.

But in the real world, important tasks are rarely one-off Q&A.

Truly valuable things usually look like this:

• Building a product isn’t one prompt.
• Finding a job isn’t one prompt.
• Growing an account isn’t one prompt.
• Learning AI isn’t one prompt.
• Maintaining a codebase isn’t one prompt either.

These tasks go on. They change. New facts appear. Old judgments get overturned. They need periodic reviews.

At that point, AI that can only “answer” isn’t enough.

It has to be able to follow through.

That’s also why long horizon is becoming important.

Because AI moving from chatbot to agent is, at heart, moving from “answering questions” to “continuously completing tasks.”

And once it starts completing tasks, the question is no longer just “is the model smart.”

The question becomes:

• can it remember the goal;
• can it maintain state;
• can it call tools;
• can it handle failure;
• can it correct itself based on feedback;
• does it know when it should stop and ask a person.

That’s the hard part of long horizon.

An example: building an indie product

Say you’re building an indie product.

On day one, you say:

“I think the target users are women living alone overseas.”

On day two, you realize:

“Maybe it isn’t people living alone, but people who’ve started taking on family responsibilities.”

On day three, you post on RedNote and the numbers are bad. You suspect the title.

On day four, after reviewing, you realize:

maybe it isn’t the title, but that the need is expressed too convolutedly and users didn’t get it right away.

On day five, you decide:

don’t rush to convert; validate with content first.

If AI just “remembers everything,” it will get muddled.

Because some of this information is old assumptions. Some is new judgment. Some is emotion. Some is evidence. Some is just self-doubt along the way.

It can’t lay everything out flat and then randomly pull one item to influence today’s answer.

That’s why “remembering a lot” doesn’t mean “helping well.”

Memory is like a warehouse. State management is like version control.

The warehouse tells you: there’s lots of stuff here. Version control tells you: which version to go by now.

What long horizon really tests is this sense of versions.

Why does AI easily drift off course in long tasks?

I think there are a few reasons.

1. It easily treats old information as current fact

A goal you stated last month doesn’t necessarily still hold today.

You said before that you wanted to commercialize. Later you may have decided to validate the need first.

You said before that you wanted to build a complete product. Later you may have decided to make a demo first.

If AI doesn’t tell old from new, it keeps guiding you with an old map.

It looks hard-working. But the direction is already wrong.

2. It easily mistakes moods for settings

This is especially dangerous.

One day you say:

“I’m so discouraged.” “I don’t think anyone wants this product.” “Maybe I’m not cut out for this.”

These may all just be a state of the moment.

AI shouldn’t permanently remember them as:

you’re someone who gives up easily. This project has no value. You shouldn’t continue.

In a long task, AI needs to tell apart:

• is this fact or emotion?
• is this feedback from one stage, or a long-term judgment?
• is this evidence, or fatigue?

Otherwise its memory turns into misunderstanding.

3. It easily knows how to continue but not how to reassess

Many AIs are very good at writing onward.

• You say continue, it continues.
• You say change it, it changes it.
• You say switch direction, it switches too.

But in a long task, what’s truly valuable isn’t going along forever.

It’s being able to remind you:

• this direction has been tried before.
• this assumption has no evidence yet.
• this judgment conflicts with yesterday’s new information.
• it’s best to pause here instead of piling on more output.

If AI only goes along, it will seem obedient. But not necessarily reliable.

A good long-horizon agent shouldn’t just execute commands. It should keep hold of the goal and notice when things drift.

4. It easily lacks outside feedback

Long tasks can’t be done through language alone.

• Code needs tests run.
• Products need user feedback.
• Content needs data.
• Job hunting needs a record of applications and responses.
• Research needs sources checked and verified.

So long horizon isn’t just “long memory.”

It also needs an environment.

AI has to be able to interact with the outside world:

read files; call tools; run tests; look things up; update state; record results; continue based on feedback.

That’s also why agents are more complex than chatbots.

A chatbot mainly talks. An agent must be able to act in an environment.

So what abilities does long horizon actually test?

I’d break it into seven layers.

Layer one is Model.

The model itself has to understand, reason and plan.

Layer two is Memory.

It has to remember information that’s useful long term.

Layer three is Context.

It has to know which information to bring in right now, instead of stuffing in all the history.

Layer four is State.

It has to know what stage things are at, and which judgment is the latest.

Layer five is Tools.

It has to be able to read files, run code, look things up and call systems.

Layer six is Eval.

It has to be able to check whether it got things right, rather than just generating a plausible-looking answer.

Layer seven is Control.

It has to know which actions it can take automatically and which a person must confirm.

Only these seven layers together make up the ability to handle long tasks.

So long horizon isn’t a single feature.

It’s the combined capability of a whole agent system.

What does this mean for everyday users?

If you use AI for long tasks, don’t rely only on it “remembering by itself.”

You can give every long-term project a status file.

For example:

• Current goal:
• Current stage:
• Already done:
• Directions abandoned:
• Latest valid judgments:
• Questions to validate:
• Next action:
• Don’t discuss again:

The file doesn’t need to be long.

But it helps AI quickly know:

what the current version is.

If you use ChatGPT, put it in the Project Instructions or project files. If you use Claude, put it in Project Knowledge. If you use Codex / Claude Code, write it into AGENTS.md or CLAUDE.md.

Don’t expect AI to guess right automatically from a pile of chat history.

Humans doing complex projects don’t rely on brute memory either. We rely on documents, boards, logs, version history and retrospectives.

AI is the same.

You need to give it a workbench.

What does this mean for indie developers?

If you’re building an AI product, long horizon is a direction well worth thinking about.

Because the problem with many AI products isn’t that the model can’t answer. It’s that it can’t follow through.

• It doesn’t know where the user got to last time.
• It doesn’t know which assumptions have been overturned.
• It doesn’t know when to update state.
• It doesn’t know when to keep going and when to stop.
• It doesn’t know which to trust when old and new information conflict.

So a truly valuable AI product can’t just be:

user input → model output

It should be more like:

user goal → current state → past decisions → relevant material → next action → feedback on results → state update

That’s where the value of the product layer lies.

Indie developers may not be able to train a stronger model. But in a specific situation, they can design a better system for long tasks.

For example:

A fitness assistant that doesn’t just generate plans, but maintains cycles, feedback, pain, recovery and progress. A writing assistant that doesn’t just generate posts, but maintains the account’s positioning, reader feedback, past topics and banned expressions. A job-search assistant that doesn’t just edit résumés, but maintains target roles, application records, résumé versions and interview feedback. A coding agent that doesn’t just write code, but maintains project rules, test commands, past bugs, the current branch and verification results.

These are all long-horizon product opportunities.

Not “the model talks better,” but “the system keeps working better.”

Finally

So the long horizon I understand now isn’t a buzzword for showing off.

It’s asking a very plain question:

can AI stay with a person and really see a complex thing through?

Not giving a beautiful answer today.

Not starting over tomorrow.

Not acting like a new intern every time.

But knowing:

• where we are;
• why we got here;
• which judgments have expired;
• which questions haven’t been validated;
• what to do next;
• when to bring a person in to judge.

That’s the key to AI moving from chatbot to agent.

A weak AI only answers the present. An average AI remembers the past. A truly good AI manages change.

And what long tasks need most is precisely not an answer machine that never stops talking.

It’s a collaborator who can stay clear-headed over time.